home *** CD-ROM | disk | FTP | other *** search
/ The World's Largest Collection of Windows Software / The World's Largest Collection of Windows Software - Disc 1.iso / connect / _j2 / wvnsc926 / rcs / wvcoding.c < prev    next >
C/C++ Source or Header  |  1994-09-21  |  92KB  |  3,363 lines
  1. head     1.12;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.12
  10. date     94.09.18.22.44.20;  author jcooper;  state Exp;
  11. branches ;
  12. next     1.11;
  13.  
  14. 1.11
  15. date     94.09.16.00.58.48;  author jcooper;  state Exp;
  16. branches ;
  17. next     1.10;
  18.  
  19. 1.10
  20. date     94.08.24.18.00.29;  author jcooper;  state Exp;
  21. branches ;
  22. next     1.9;
  23.  
  24. 1.9
  25. date     94.08.11.21.03.19;  author rushing;  state Exp;
  26. branches ;
  27. next     1.8;
  28.  
  29. 1.8
  30. date     94.08.11.20.16.25;  author rushing;  state Exp;
  31. branches ;
  32. next     1.7;
  33.  
  34. 1.7
  35. date     94.08.11.00.09.17;  author jcooper;  state Exp;
  36. branches ;
  37. next     1.6;
  38.  
  39. 1.6
  40. date     94.07.25.20.05.13;  author jcooper;  state Exp;
  41. branches ;
  42. next     1.5;
  43.  
  44. 1.5
  45. date     94.05.23.18.36.00;  author jcooper;  state Exp;
  46. branches ;
  47. next     1.4;
  48.  
  49. 1.4
  50. date     94.03.01.19.14.22;  author rushing;  state Exp;
  51. branches ;
  52. next     1.3;
  53.  
  54. 1.3
  55. date     94.02.24.21.28.04;  author jcoop;  state Exp;
  56. branches ;
  57. next     1.2;
  58.  
  59. 1.2
  60. date     94.02.09.18.01.08;  author cnolan;  state Exp;
  61. branches ;
  62. next     1.1;
  63.  
  64. 1.1
  65. date     94.01.18.09.54.20;  author jcoop;  state Exp;
  66. branches ;
  67. next     ;
  68.  
  69.  
  70. desc
  71. @jcoop's en/decoding routines
  72. @
  73.  
  74.  
  75. 1.12
  76. log
  77. @Better handling of status windows, using IsBusy flag, etc
  78. @
  79. text
  80. @/********************************************************************
  81.  *                                                                  *
  82.  *  MODULE    :  WVCODING.C                                         *
  83.  *                                                                  *
  84.  *  PURPOSE   : This file contains functions for en/decoding files  *
  85.  *                                                                  *
  86.  *  ENTRY POINTS:                                                   *
  87.  *            DecodeInit  - initializes decoding resources        *
  88.  *        DecodeDone  - frees decoding resources              *
  89.  *        InitCoded   - initializes a coded block             * 
  90.  *                  called for each new art to decode     *
  91.  *        DecodeLine  - Main decoding engine.  Called once    *
  92.  *                  for each input line                   *
  93.  *        DecodeFile  - Uses file instead of comm input as a  *
  94.  *                     line provider to the decoding engine  *
  95.  *        DecodeDoc   - Uses a Doc instead of comm input as a *
  96.  *                     line provider to the decoding engine  *
  97.  *    CompleteThisDecode  - Called at end of each article - adds  *
  98.  *                  block to appropriate decode thread,   *
  99.  *                  writes to disk if possible, etc       *
  100.  *                  Encode  - Encodes a file into a text block      *
  101.  *            EncodeToFile  - Calls Encode, then writes block to    * 
  102.  *                            an output file                        *
  103.  *                                                                  *
  104.  *  NOTES:                                                          *
  105.  *    Both the max # of batched decode files and the max #        * 
  106.  *    threads per file are fixed.  This should be made dynamic    *
  107.  *    at some point I guess.                                      *
  108.  *                                                                  *
  109.  * Author: John S. Cooper (jcooper@@netcom.com)                      *
  110.  *   Date: Sept 13, 1993                                            *
  111.  *                                                                  *
  112.  * Let me know if you like this code, or if you re-use any piece of *
  113.  * it. I'm just curious to know what people think.                  *
  114.  ********************************************************************/
  115. /* 
  116.  * $Id: wvcoding.c 1.11 1994/09/16 00:58:48 jcooper Exp $
  117.  * $Log: wvcoding.c $
  118.  * Revision 1.11  1994/09/16  00:58:48  jcooper
  119.  * new coding-status window style.  optimized info-header parser.
  120.  * general cleanup for 92.6
  121.  * 
  122.  * Revision 1.10  1994/08/24  18:00:29  jcooper
  123.  * misc encoding/decoding changes
  124.  *
  125.  * Revision 1.9  1994/08/11  21:03:19  rushing
  126.  * FindExecutable fix for NT
  127.  *
  128.  * Revision 1.8  1994/08/11  20:16:25  rushing
  129.  * bug fix
  130.  *
  131.  * Revision 1.6  1994/07/25  20:05:13  jcooper
  132.  * execution of decoded files
  133.  *
  134.  * Revision 1.5  1994/05/23  18:36:00  jcooper
  135.  * new attach code, session [dis]connect
  136.  *
  137.  * Revision 1.4  1994/03/01  19:14:22  rushing
  138.  * ifdef'd the DEBUG info
  139.  *
  140.  * Revision 1.3  1994/02/24  21:28:04  jcoop
  141.  * jcoop changes.
  142.  *
  143.  * Revision 1.2  1994/02/09  18:01:08  cnolan
  144.  * cnolan 90.2 changes
  145.  *
  146.  * Revision 1.1  1994/01/18  09:54:20  jcoop
  147.  * Initial revision
  148.  *
  149.  */ 
  150. #include <windows.h>
  151. #include <windowsx.h>
  152. #include "wvglob.h"
  153. #include "winvn.h"
  154. #pragma hdrstop
  155. #include <string.h>
  156. #include <stdio.h>
  157. #include <stdlib.h>
  158. #include <ctype.h>        /* for isspace, isalnum, etc */
  159.  
  160. #ifdef _DEBUG
  161. #define DEBUG_MAP
  162. #define DEBUG_MEM
  163. #define DEBUG_DECODE
  164. #endif
  165.  
  166. #define LOW        1    // sequence confidence levels
  167. #define HIGH            2
  168. #define UNUSED        127    // unused mapping slots
  169.  
  170. #define END_BLOCK    2
  171. #define CODE_LINE_LEN    45    
  172. /*
  173.  * Globals for this func
  174.  */
  175. char
  176.     xxTable[CODINGTABLESIZE] = "+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  177. char
  178.     uuTable[CODINGTABLESIZE] = "`!\"#$%&'()*+,-./0123456789:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
  179. char
  180.     base64Table[CODINGTABLESIZE] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  181. char    *codingTable;
  182. char     customTable[CODINGTABLESIZE];
  183.  
  184. TypDecodeThread *threadList[MAX_DECODE_THREADS];
  185. int    numDecodeThreads;        // number of active decode threads
  186. int    currentDecodeThread;
  187. int    numDumbDecoded;
  188. BOOL    bossanovaMIME;                  // = TRUE if found MIME Version header
  189. int      thisNumBlocks;             // MIME vars for current block
  190. char     thisContentType[80];
  191. char    thisContentDesc[MAXINTERNALLINE];
  192. char    thisBoundary[MAXINTERNALLINE];
  193. int    thisContentEncoding, prevContentEncoding;
  194. char     prevBlockIdent[MAXFILENAME];
  195. /*
  196.  * Private functions
  197.  */
  198. int     EncodeLine (unsigned char *outLine, unsigned char *line, int start, int num);
  199. void    EncodeUnit (unsigned char *out, unsigned char *in, int num);
  200. int    GetThreadByName (char *name);
  201. int    AddToThreadList ();
  202. void     DestroyThread (int num);
  203. void    DestroyCodedBlock (TypCoded **thisCoded);
  204. void    InsertBlockInThread (int num, TypCoded *thisBlock, int index);
  205. void    DeleteBlockFromThread (int num, int index);
  206. BOOL    WriteDecodeThread(int num);
  207. BOOL    WriteBlockToFile(int num, TypCoded *thisDecode);
  208. BOOL    WriteTopBlockToFile (int num, int *endFlag);
  209. BOOL    AddDataToBlock (TypCoded *thisDecode, char *newData, unsigned int dataLen);
  210. void    ParseInfoLine (TypCoded *thisDecode, char *line, BOOL guessIdent);
  211. BOOL    ParseAppSpecificLine (TypCoded *thisDecode, char *line);
  212. char     *ReadSubjectToken (char *dest, char **ptr);
  213. BOOL    isnumber (char *str);
  214. BOOL    SearchThreadNames (char *name);
  215. int    ParseMimeHeaderLine (TypCoded *thisDecode, char *line);
  216. int    ParseMimeContentType (TypCoded *thisDecode, char *line);
  217.  
  218. void CreateCodingStatusWnd();
  219. int    DecodeDataLine (TypCoded *decode, char *line);
  220. void     CreateUUTable();
  221. BOOL    TestIgnoreLine (char *line);
  222. int    IsDataLine (char *line);
  223. BOOL     TestDataLine (char *line);
  224. int     ThreadTable (char *dest, char *name);
  225. void    UpdateThreadStatus (int num, char *str);
  226.  
  227. void    ExecuteDecodedFile (int num, char *fileName);
  228.  
  229. #if defined(DEBUG_DECODE) || defined(DEBUG_MEM)
  230. #define DEBUG_FILE "coding.log"
  231. void     DebugLog();
  232. void     InitDebugLog();
  233. char     debug[MAXCOMMLINE];
  234. OFSTRUCT debugFileStruct;
  235. #endif
  236.  
  237. #if defined(DEBUG_DECODE) || defined(DEBUG_MEM)
  238. /* ------------------------------------------------------------------------
  239.  * Debug log handler
  240.  * Open/close the file for every addition to log, so all info is safely
  241.  * captured in case of GPF
  242.  */
  243. void
  244. DebugLog ()
  245. {
  246.     HFILE hDebugFile;
  247.  
  248.         if ((hDebugFile = OpenFile ((char far *)NULL, &debugFileStruct, OF_REOPEN|OF_WRITE)) >= 0)
  249.     {       
  250.         _llseek(hDebugFile, 0L, 2);    /* go to end */
  251.             _lwrite(hDebugFile, debug, strlen(debug));
  252.             _lclose(hDebugFile);
  253.         }
  254. }
  255. void
  256. InitDebugLog ()
  257. {
  258.     HFILE hDebugFile;
  259.  
  260.         if ((hDebugFile = OpenFile ((char far *)DEBUG_FILE, &debugFileStruct, OF_CREATE)) >= 0)
  261.     {
  262.             sprintf(debug, "New log");
  263.             _lwrite(hDebugFile, debug, strlen(debug));
  264.             _lclose(hDebugFile);
  265.         }
  266. }
  267. #endif
  268. /* ------------------------------------------------------------------------
  269.  * Decode a file
  270.  * Uses a file instead of the comm article as a line-provider to the 
  271.  * decode routines
  272.  */
  273. void
  274. DecodeFile (HWND hParentWnd)
  275. {
  276.     FILE *DecodeFile;
  277.         char mybuf[MAXINTERNALLINE], fileName[MAXFILENAME], *ptr;
  278.         int result;
  279.  
  280.         if (AskForExistingFileName (hParentWnd, fileName, "Open encoded file") == FAIL)
  281.             return;
  282.  
  283.     DecodeInit();
  284.     if ((DecodeFile = fopen (fileName, "r")) == NULL)
  285.     {
  286.         MessageBox (hParentWnd, "Failure to read file", "File error", MB_OK);
  287.         return;
  288.     } 
  289.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  290.     {
  291.         MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  292.         return;
  293.     }
  294.            while (1)
  295.            {
  296.                if ((ptr = fgets(mybuf, MAXINTERNALLINE, DecodeFile)) == NULL)
  297.                    strcpy (mybuf, "EOF");    // make sure wrap up occurs
  298.  
  299.         result = DecodeLine (currentCoded, mybuf);
  300.         if (result == FAIL)
  301.         {
  302.                  MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  303.             goto abortDecodeFile;
  304.         }           
  305.         if (result == END_BLOCK)
  306.         {
  307.             if (CompleteThisDecode () == FAIL)
  308.             {
  309.                      MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  310.                 goto abortDecodeFile;
  311.             }           
  312.                if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  313.             {
  314.                 MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  315.                 goto abortDecodeFile;
  316.             }
  317.         }
  318.         if (ptr == NULL)    // EOF
  319.             break;
  320.     }
  321.  
  322.     if (currentCoded != NULL)    // finish final block
  323.         CompleteThisDecode ();
  324.    
  325.    abortDecodeFile:;
  326.           fclose(DecodeFile);
  327.     DecodeDone ();
  328. }
  329. /* ------------------------------------------------------------------------
  330.  * Decode a doc
  331.  * Uses a doc instead of the comm article as a line-provider to the 
  332.  * decode routines
  333.  */
  334. void
  335. DecodeDoc (HWND hParentWnd, TypDoc *Document)
  336. {
  337.         int result;
  338.     TypBlock far *BlockPtr;
  339.     TypLine far *LinePtr;
  340.             
  341.     DecodeInit();
  342.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  343.     {
  344.         MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  345.         return;
  346.     }
  347.     
  348.     LockLine (Document->hFirstBlock, sizeof (TypBlock), (TypLineID) 0L, &BlockPtr, &LinePtr);
  349.     while (LinePtr->length != END_OF_BLOCK)
  350.     {
  351.         result = DecodeLine (currentCoded, 
  352.                 ((char far *) LinePtr) + sizeof (TypText) + sizeof (TypLine));
  353.  
  354.         if (result == FAIL)
  355.         {
  356.                  MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  357.             goto abortDecodeDoc;
  358.         }           
  359.  
  360.         if (result == END_BLOCK)
  361.         {
  362.             if (CompleteThisDecode () == FAIL)
  363.             {
  364.                      MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  365.                 goto abortDecodeDoc;
  366.             }           
  367.                if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  368.             {
  369.                 MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  370.                 return;
  371.             }
  372.         }
  373.         NextLine (&BlockPtr, &LinePtr);
  374.     }
  375.     if (currentCoded != NULL)    // finish final block
  376.         CompleteThisDecode ();
  377.    
  378.    abortDecodeDoc:;
  379.     GlobalUnlock (BlockPtr->hCurBlock);
  380.     DecodeDone ();
  381. }
  382. /* ------------------------------------------------------------------------
  383.  *    Encode a file and ask the user for a file to name to store it in
  384.  */
  385. void
  386. EncodeToFile (HWND hParentWnd, char *inFile)
  387. {
  388.    register unsigned long i;
  389.    char fileName[MAXFILENAME];
  390.    OFSTRUCT outFileStruct;
  391.    HFILE hAttachFile;
  392.    TypTextBlock *encodeData;
  393.  
  394.    if ((encodeData = InitTextBlock (hParentWnd)) != NULL)
  395.    {
  396.       CreateStatusArea(hParentWnd);
  397.       strcpy (currentCoded->ident, inFile);    // status window info
  398.  
  399.       if (Encode (encodeData, inFile, ADD_TO_FILE) != FAIL)
  400.       {
  401.     fileName[0]='\0';        
  402.     if (AskForNewFileName (hParentWnd, fileName, "", FALSE) != FAIL)
  403.     {
  404.        if ((hAttachFile = OpenFile ((char far *) fileName, &outFileStruct, OF_CREATE)) < 0)
  405.         MessageBox(hParentWnd, "Unable to open output file", "File Error", MB_OK|MB_ICONSTOP);
  406.        else
  407.        {
  408.           for (i = 0; i < encodeData->numLines; i++)
  409.           _lwrite (hAttachFile, TextBlockLine (encodeData, i), lstrlen(TextBlockLine (encodeData, i)));
  410.           _lclose (hAttachFile);
  411.        }
  412.     }    
  413.       }     
  414.       FreeTextBlock (encodeData);
  415.       DestroyStatusArea ();
  416.    }   
  417. }
  418.  
  419. /* ------------------------------------------------------------------------
  420.  *    Create a status window a coding block used for status info
  421.  *    the currentCoded block is purely for status in this case
  422.  *    This is used by attach and EncodeFile and ReadFileToTextBlock
  423.  *    to show status in progress
  424.  *    Use UpdateBlockStatus to update/display status
  425.  *    Use DestroyStatusArea to clean up when done
  426.  */
  427. void
  428. CreateStatusArea (HWND hParentWnd)
  429. {
  430.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  431.         return;
  432.     CreateCodingStatusWnd();
  433.     currentCoded->sequence = 1;        // status window info
  434.  
  435. }
  436.  
  437. void
  438. DestroyStatusArea ()
  439. {
  440.     DestroyCodedBlock (¤tCoded);
  441.     DestroyWindow (hCodedBlockWnd);
  442.     hCodedBlockWnd = (HWND)NULL;
  443. }
  444.  
  445. void
  446. CreateCodingStatusWnd()
  447. {
  448.     /* Create coding status window, top center */
  449.     hCodedBlockWnd = CreateWindowEx (WS_EX_DLGMODALFRAME, "WinVnBlockCoding", "Block Encoding Status",
  450.             WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_THICKFRAME,
  451.             (xScreen-STATUSWIDTH)>>1, 1, STATUSWIDTH, STATUSHEIGHT,
  452.             (HWND)NULL, (HMENU)NULL, hInst, (void far *)NULL);
  453.     
  454.     SetHandleBkBrush( hCodedBlockWnd, hStatusBackgroundBrush);
  455.     ShowWindow (hCodedBlockWnd, SW_SHOWNORMAL);
  456. }
  457.  
  458.  
  459. /* ------------------------------------------------------------------------
  460.  *    Adds text to a thread coding status block, and refreshes
  461.  *    the thread status window
  462.  */    
  463. void
  464. UpdateThreadStatus (int num, char *str)
  465. {
  466.     AddLineToTextBlock (threadList[num]->statusText, str);
  467.     InvalidateRect (threadList[num]->statusText->hTextWnd, NULL, FALSE);
  468.     UpdateWindow (threadList[num]->statusText->hTextWnd);
  469. }
  470.  
  471. /* ------------------------------------------------------------------------
  472.  *    Refreshes the block status window
  473.  */    
  474. void
  475. UpdateBlockStatus ()
  476. {
  477.     InvalidateRect (hCodedBlockWnd, NULL, FALSE);
  478.     UpdateWindow (hCodedBlockWnd);
  479. }
  480.  
  481. /* ------------------------------------------------------------------------
  482.  *    Encode a file 
  483.  *    Called _after_ the attach dialog, so all globals for this encode
  484.  *    are set  (sorry about the globals...)
  485.  *    Result is encoded file in TextBlock 
  486.  *    Assumes currentCoded is initialized
  487.  */
  488. int 
  489. Encode (TypTextBlock *textBlock, char *fileName, int mode)
  490. {
  491.     HFILE hFile;
  492.         int numRead, lineLen, start;
  493.     register int i;
  494.     unsigned char inBuf[CODE_LINE_LEN];
  495.     unsigned char outLine[MAXINTERNALLINE];
  496.     extern char *NameWithoutPath ();
  497.  
  498.     CodingState = ATTACH_PROCESSING;
  499.  
  500.     // Set up encoding map
  501.     switch (EncodingTypeNum)
  502.     {
  503.     case CODE_BASE64:    
  504.         codingTable = base64Table;
  505.         break;
  506.     case CODE_UU:
  507.         codingTable = uuTable;
  508.         break;
  509.     case CODE_XX:
  510. //    Note, XX table is hard coded in declarations for simplicity
  511.         codingTable = xxTable;
  512.         break;
  513.     case CODE_CUSTOM:
  514.         codingTable = UserCodingTable;
  515.         // add 2 table lines
  516.         if (AddEndedLineToTextBlock (textBlock, "table", mode))
  517.             return (FAIL);
  518.         memmove (str, UserCodingTable, 32);
  519.         str[32] = '\0';
  520.         if (AddEndedLineToTextBlock (textBlock, str, mode))
  521.             return (FAIL);
  522.         memmove (str, &UserCodingTable[32], 32);
  523.         if (AddEndedLineToTextBlock (textBlock, str, mode))
  524.             return (FAIL);
  525.         break;
  526.     }
  527.  
  528.     // Prepare for encoding
  529.     switch (EncodingTypeNum)
  530.     {
  531.     case CODE_UU:
  532.     case CODE_XX:
  533.     case CODE_CUSTOM:
  534.         // these are 3-to-4 encodings with 1st char indicating line len
  535.         // and block starts with 'begin' line and ends with 'end' line
  536.         // add 'begin' line
  537.         NameWithoutPath (str, fileName);
  538.         sprintf (outLine, "begin 755 %s", str);
  539.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  540.             return (FAIL);
  541.         currentCoded->numLines++;
  542.             // set 1st char to appropriate line length value
  543.             outLine[0] = codingTable[CODE_LINE_LEN];
  544.             start = 1;    // count includes the count char itself
  545.         break;
  546.     case CODE_BASE64:
  547.         // base64 is a 3-to-4 encoding, with no line len indicator and 
  548.         // no 'begin' or 'end' lines
  549.         start = 0;
  550.     }
  551.     lineLen = CODE_LINE_LEN;
  552.  
  553.     // open the file and have at it    
  554.         hFile = _lopen (fileName, OF_READ);
  555.         while (1)
  556.         {
  557.             if ((numRead = _lread(hFile, inBuf, lineLen)) == 0)
  558.                 break;
  559.         if (numRead < lineLen)    // last line length value
  560.         {
  561.             if (EncodingTypeNum != CODE_BASE64)
  562.                 outLine[0] = codingTable[numRead];
  563.             
  564.             for (i = numRead; i < lineLen; i++)
  565.                 inBuf[i] = 0;
  566.         }
  567.             EncodeLine (outLine, inBuf, start, numRead);
  568.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  569.             return (FAIL);
  570.         currentCoded->numLines++;
  571.         currentCoded->numBytes += numRead;
  572.             if (currentCoded->numLines % STATUS_UPDATE_FREQ == 0)
  573.                 UpdateBlockStatus ();
  574.     }        
  575.     _lclose(hFile);
  576.     switch (EncodingTypeNum)
  577.     {
  578.     case CODE_UU:
  579.     case CODE_XX:
  580.     case CODE_CUSTOM:
  581.             // add zero length line
  582.             outLine[0] = codingTable[0];
  583.             outLine[1] = '\0';
  584.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  585.             return (FAIL);
  586.         // add 'end' line
  587.         strcpy (outLine, "end");
  588.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  589.             return (FAIL);
  590.         currentCoded->numLines+=2;
  591.         }
  592.     UpdateBlockStatus ();
  593.     
  594.     CodingState = INACTIVE;
  595.     return (SUCCESS);
  596. }
  597.     
  598. /* ------------------------------------------------------------------------
  599.  *    Encode num chars from line
  600.  *    Put data in outLine starting at start
  601.  */
  602. int 
  603. EncodeLine (unsigned char *outLine, unsigned char *line, int start, int num)
  604. {
  605.     register int i, j;
  606.     
  607.     for (j = start, i = 0; i < num; j+=4, i+=3)
  608.         EncodeUnit (&outLine[j], &line[i], (i+3 > num) ? num - i : 3);
  609.  
  610.     outLine[j] = '\0';
  611.     return (j);
  612. }
  613.     
  614. void
  615. EncodeUnit (unsigned char *out, unsigned char *in, int num)
  616. {
  617.            out[0] = codingTable[((in[0]>>2) & 63)];
  618.     out[1] = codingTable[(((in[0]<<4)|(in[1]>>4)) & 63)];
  619.     if (num == 1)
  620.     {
  621.         if (EncodingTypeNum == CODE_BASE64)
  622.             strcpy (&out[2], "==");
  623.         return;
  624.     }
  625.  
  626.     out[2] = codingTable[(((in[1]<<2)|(in[2]>>6)) & 63)];
  627.     if (num == 2)
  628.     {
  629.         if (EncodingTypeNum == CODE_BASE64)
  630.             strcpy (&out[3], "=");
  631.         return;
  632.     }
  633.  
  634.     out[3] = codingTable[(in[2] & 63)];
  635. }
  636. /* ------------------------------------------------------------------------
  637.  *    Init for decoding
  638.  *     Initialize the coding tables
  639.  *    Init threadList:  list of pointers to Thread lists 
  640.  *    (one thread for each file being decoded)
  641.  *        
  642.  */
  643. void
  644. DecodeInit ()
  645. {
  646.     register int i;
  647.     
  648. #ifdef DEBUG_MEM
  649.     InitDebugLog();
  650. #endif
  651.     
  652.         for (i = 0; i < MAX_DECODE_THREADS; i++)
  653.             threadList[i] = NULL;
  654.  
  655.     currentCoded = (TypCoded *) NULL;
  656.     CodingState = DECODE_SKIPPING;
  657.     numDecodeThreads = 0;
  658.     numDumbDecoded = 0;
  659.     currentDecodeThread = -1;    
  660.     thisNumBlocks = -1;
  661.     prevBlockIdent[0] = '\0';
  662.     thisContentEncoding = CODE_UNKNOWN;
  663.     prevContentEncoding = CODE_UNKNOWN;
  664.         customTable[0] = '\0';
  665.  
  666. #ifdef DEBUG_MEM
  667.     sprintf(debug, "\nInitialized decoding, %d threads", MAX_DECODE_THREADS);
  668.     DebugLog();
  669. #endif
  670.     // Create coding status window (open for duration of coding only)
  671.     CreateCodingStatusWnd();
  672.     UpdateBlockStatus ();
  673. }
  674.  
  675. /* ------------------------------------------------------------------------
  676.  * At this point, all threads in sequence should have been written and freed,
  677.  * If any threads left, we either had an incomplete decode of some file,
  678.  * or the file was encoded w/out sequence info, and we were waiting to 
  679.  * hopefully receive it all.  If we had an endflag, then write it in order
  680.  * received
  681.  * Accepts handle of parent window so it can display any 'incomplete' messages
  682.  */
  683. void
  684. DecodeDone ()
  685. {
  686.     char mybuf[MAXINTERNALLINE], name[MAXINTERNALLINE];
  687.  
  688. #ifdef DEBUG_MEM
  689.     sprintf(debug, "\nDone coding,  Wrapping up stray threads");
  690.     DebugLog();
  691. #endif
  692.     name[0]='\0';            // only show name if not verbose mode
  693.     while (numDecodeThreads > 0)    // always work on top of list [0]
  694.     {
  695.         if (!CodingStatusVerbose)
  696.             if (threadList[0]->name[0] != '\0')
  697.                 sprintf (name, "%s   ", threadList[0]->name);
  698.             else
  699.                 sprintf (name, "%s   ", threadList[0]->ident);
  700.  
  701.         if (threadList[0]->numBlocks == 0)
  702.         {    // premature end of file
  703.                     WriteDecodeThread (0);
  704.             sprintf (mybuf, "%sDecode is missing parts, written total size %ld", name, threadList[0]->totalBytes);
  705.             UpdateThreadStatus (0, mybuf);
  706.         }
  707.         else if (threadList[0]->contentEncoding != CODE_BASE64 &&
  708.                 !threadList[0]->codedBlockList[threadList[0]->numBlocks-1]->endFlag)
  709.         {
  710.             sprintf (mybuf, "%sEnd never found.  Cancelling", name);
  711.             UpdateThreadStatus (0, mybuf);
  712.         }
  713.         else if (threadList[0]->expectedNumBlocks > 0)
  714.         {    // there IS sequencing info, so we should not be here
  715.                     WriteDecodeThread (0);
  716.             sprintf (mybuf, "%sDecode is missing parts, written total size %ld", name, threadList[0]->totalBytes);
  717.             UpdateThreadStatus (0, mybuf);
  718.         }
  719.         else
  720.                 {
  721.             sprintf (mybuf, "%sCompleteness confidence is medium, written total size %ld", name, threadList[0]->totalBytes);
  722.             UpdateThreadStatus (0, mybuf);
  723.                     WriteDecodeThread (0);
  724.         }            
  725.         DestroyThread (0);    // decrements numDecodeThreads
  726.     }
  727.     currentCoded = NULL;
  728.     CodingState = INACTIVE;
  729.         CommDecoding = FALSE;
  730.     DestroyWindow (hCodedBlockWnd);
  731.     hCodedBlockWnd = (HWND)NULL;
  732. }    
  733.  
  734. /* ------------------------------------------------------------------------
  735.  *     Initialize a coded object, and initial data space
  736.  *    Returns ptr to object or NULL if failed
  737.  */
  738. TypCoded *
  739. InitCoded (HWND hParentWnd)
  740. {      
  741.     TypCoded *thisCoded = NULL;
  742.     
  743. #ifdef DEBUG_MEM
  744.     sprintf(debug, "\nInitializing a coded object");
  745.     DebugLog();
  746. #endif
  747.     if ((thisCoded = (TypCoded *) GlobalAllocPtr ( GMEM_MOVEABLE, sizeof (TypCoded))) == NULL)
  748.         return ((TypCoded *) NULL);
  749.     
  750. #ifdef DEBUG_MEM
  751.     sprintf(debug, "\nAllocing data size %d", BASE_BLOCK_SIZE);
  752.     DebugLog();
  753. #endif
  754.     if ((thisCoded->data = (char huge *) GlobalAllocPtr (GMEM_MOVEABLE, BASE_BLOCK_SIZE * sizeof (char))) == NULL)
  755.         return ((TypCoded *) NULL);
  756.  
  757.     thisCoded->maxBytes = BASE_BLOCK_SIZE;
  758.     thisCoded->numBytes = 0;
  759.     thisCoded->numLines = 0;
  760.     thisCoded->sequence = -1;
  761.     thisCoded->seqConfidence = 0;
  762.     thisCoded->name[0] = '\0';
  763.     thisCoded->ident[0] = '\0';
  764.     thisCoded->endFlag = thisCoded->beginFlag = FALSE;
  765.     thisCoded->hParentWnd = hParentWnd;
  766.         bossanovaMIME = FALSE;
  767.     
  768.     return (thisCoded);
  769. }    
  770.  
  771. /* ------------------------------------------------------------------------
  772.  *     Destroy a thread
  773.  *    Destroy all blocks in the thread
  774.  *    Remove the thread from the threadList
  775.  */
  776. void
  777. DestroyThread (int num)
  778. { 
  779.     register int i;
  780.     
  781. #ifdef DEBUG_MEM
  782.     sprintf(debug, "\nDestroying thread %d", num);
  783.     DebugLog();
  784. #endif
  785.     if (CodingStatusVerbose)
  786.         threadList[num]->statusText->IsBusy = FALSE;
  787.     
  788.     for (i = 0; i < threadList[num]->numBlocks; i++)
  789.         DestroyCodedBlock (&(threadList[num]->codedBlockList[i]));
  790.         
  791.     GlobalFreePtr (threadList[num]);
  792.  
  793.     for (i = num; i < numDecodeThreads; i++)
  794.         threadList[i] = threadList[i + 1];
  795.     
  796.     numDecodeThreads--;
  797.     if (currentDecodeThread == num)
  798.         currentDecodeThread = max (0, currentDecodeThread - 1);
  799. }
  800. /* ------------------------------------------------------------------------
  801.  *     Destroy a coded block structure
  802.  *    Free the huge data.  Takes a ptr to a ptr so it can NULL it when done
  803.  */
  804. void
  805. DestroyCodedBlock (TypCoded **thisCoded)
  806. {        
  807. #ifdef DEBUG_MEM
  808.     sprintf(debug, "\nDestroying block sequence %d", (*thisCoded)->sequence);
  809.     DebugLog();
  810. #endif
  811.     GlobalFreePtr ((*thisCoded)->data);
  812.     GlobalFreePtr (*thisCoded);
  813.         *thisCoded = NULL;
  814. }
  815.  
  816. /* ------------------------------------------------------------------------
  817.  *     Given a file name, find the associated thread number  
  818.  *    Returns -1 if no thread by that name exists
  819.  */
  820. int
  821. GetThreadByName (char *name)
  822. {
  823.     int i, result;
  824.     
  825.     for (result = -1, i = 0; i < numDecodeThreads && result == -1; i++)
  826.         if (!_stricmp (name, threadList[i]->name))
  827.             result = i;
  828.  
  829.     return (result);
  830. }
  831. /* ------------------------------------------------------------------------
  832.  *     Determine if a thread has already been started for this ident
  833.  *    if yes, add decode object to that thread
  834.  *    otherwise, alloc a new thread list structure, add this block to it
  835.  *    At end, currentDecodeThread is set to handle of thread
  836.  */
  837. BOOL                                                           
  838. AddToThreadList ()
  839. {
  840.     register int i;
  841.     int num;
  842.     char mybuf[MAXINTERNALLINE];
  843.     int x, y, width, height, maxX, maxY;
  844.     
  845.      if (DumbDecode)
  846.      {    
  847.         if (numDecodeThreads == 0)
  848.              num = -1;
  849.         else 
  850.              num = 0;
  851.     } else
  852.      /* Search existing threads for an ident match.  If
  853.       * no match found, or no threads exist yet, add new thread.
  854.       */
  855.         for (num = -1, i = 0; i < numDecodeThreads; i++)
  856.             if (!_stricmp (currentCoded->ident, threadList[i]->ident))
  857.                 num = i;
  858.  
  859.     if (num == -1)        /* add a new thread */
  860.     {
  861.         if ((numDecodeThreads + 1) > MAX_DECODE_THREADS)    
  862.         {
  863.             return (FAIL);
  864. /*            GlobalUnlock(decodeObjectHandles);
  865.               decodeObjectHandles = GlobalRealloc (decodeFileHandles,
  866.                   (numDecodeThreads + LIST_SIZE_INC) * sizeof (HGLOBAL), 
  867.                   GMEM_MOVEABLE);
  868.             threadList = (HGLOBAL *) GlobalLock (decodeFileHandles);
  869. */
  870.         }
  871.  
  872. // create a new DecodeThreadStruct object, store its handle in threadList,
  873. #ifdef DEBUG_MEM
  874.         sprintf(debug, "\nCreating new thread ident %s", currentCoded->ident);
  875.         DebugLog();
  876. #endif
  877.          num = numDecodeThreads;
  878.         numDecodeThreads++;
  879.  
  880.         threadList[num] = (TypDecodeThread *) GlobalAllocPtr (GMEM_MOVEABLE, sizeof (TypDecodeThread));
  881.         threadList[num]->expectedNumBlocks = 0;
  882.         threadList[num]->numBlocksWritten = 0;
  883.         threadList[num]->numBlocks = 0;
  884.         threadList[num]->totalBytes = 0;
  885.         threadList[num]->dosFileName[0] = '\0';
  886.         if (thisContentEncoding == CODE_CUSTOM)
  887.             strncpy (threadList[num]->customTable, customTable, CODINGTABLESIZE);
  888.         threadList[num]->contentEncoding = thisContentEncoding;
  889.         strcpy (threadList[num]->ident, currentCoded->ident);
  890.                 if (currentCoded->name[0] != '\0')
  891.             strcpy (threadList[num]->name, currentCoded->name);
  892.         else
  893.             threadList[num]->name[0] = '\0';
  894.  
  895.             if (CodingStatusVerbose || NumStatusTexts == 0)
  896.         {
  897.            if ((threadList[num]->statusText = InitTextBlock(hCodedBlockWnd)) == NULL)
  898.             MessageBox (hCodedBlockWnd, "Memory allocation error in text block", "Memory Error", MB_OK);
  899.                 
  900.                    if (NumStatusTexts + 1 > MAX_DECODE_THREADS);
  901.                        // ?????
  902.                 
  903.                    CodingStatusText[NumStatusTexts++] = threadList[num]->statusText;
  904.  
  905.            if (CodingStatusVerbose)
  906.                sprintf(mybuf, "Decoding Status for file %s", (threadList[num]->name[0]!='\0')?threadList[num]->name:threadList[num]->ident);
  907.            else
  908.                strcpy(mybuf, "Decoding Status");
  909.            
  910.            width = xScreen>>1;
  911.            height = (yScreen>>1) - CaptionHeight;
  912.            maxX = 3 * (width>>1);    /* 3/4 screen width  */
  913.            maxY = 3 * (height>>1);    /* 3/4 screen height */
  914.  
  915.            x = (NumStatusTexts * 10) % maxX;
  916.            y = (yScreen>>2) + (NumStatusTexts * CaptionHeight) % maxY;
  917.  
  918.            threadList[num]->statusText->hTextWnd =
  919.             CreateWindow ("WinVnCoding", mybuf,
  920.                 WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
  921.                 x, y, width, height,
  922.                 (HWND)NULL, (HMENU)NULL, hInst, (void far *)NULL);
  923.  
  924.            if (threadList[num]->statusText->hTextWnd == (HWND)NULL)
  925.            {
  926.             FreeTextBlock(threadList[num]->statusText);    
  927.             MessageBox (hCodedBlockWnd, "Couldn't create status text window","Window Creation Error", MB_OK);
  928.             return (FAIL);            
  929.            }
  930.            SetHandleBkBrush (threadList[num]->statusText->hTextWnd,
  931.                       hStatusBackgroundBrush);
  932.            ShowWindow (threadList[num]->statusText->hTextWnd, SW_SHOWNORMAL);
  933.                UpdateWindow (threadList[num]->statusText->hTextWnd);
  934.         }
  935.         else
  936.            threadList[num]->statusText = CodingStatusText[0];
  937.  
  938.     }
  939.     
  940. /* If this new block enlightens us with any useful thread info, update
  941.  * the thread
  942.  */
  943.     if (currentCoded->name[0] != '\0')
  944.         strcpy (threadList[num]->name, currentCoded->name);
  945. //    if (threadList[num]->contentType[0] == '\0')
  946. //        strcpy (threadList[num]->contentType, thisContentType);
  947.     if (threadList[num]->expectedNumBlocks == 0 && thisNumBlocks > 0)
  948.         threadList[num]->expectedNumBlocks = thisNumBlocks;
  949.     
  950.     threadList[num]->totalBytes += currentCoded->numBytes;
  951. /*
  952.  * Now, add this decode object to the thread codedBlockList
  953.  * Insert in correct sequence. 
  954.  * If no sequence info available, add to end of list, but before any end block
  955.  */
  956.     if (DumbDecode)
  957.         InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks);
  958.     else
  959.     {    
  960.       if (threadList[num]->numBlocks != 0 && currentCoded->sequence == -1)
  961.       {    /* sequence unknown, add at end or before end block */
  962.         if (currentCoded->beginFlag)
  963.             InsertBlockInThread(num, currentCoded, 0);
  964.         else 
  965.         {
  966.             if (threadList[num]->codedBlockList[threadList[num]->numBlocks - 1]->endFlag)
  967.                 InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks - 1);
  968.             else            
  969.                 InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks);
  970.         }
  971.       }
  972.       else
  973.       {
  974.         for (i = 0; i < threadList[num]->numBlocks; i++)
  975.         {
  976.             if (threadList[num]->codedBlockList[i]->sequence == -1 || 
  977.                 threadList[num]->codedBlockList[i]->sequence >= currentCoded->sequence)
  978.                 break;
  979.         }
  980.         InsertBlockInThread (num, currentCoded, i);
  981.       }                                                  
  982.     }
  983.     currentDecodeThread = num;         
  984.     if (!CodingStatusVerbose)
  985.         return (SUCCESS);
  986.     
  987.     sprintf (mybuf, "Decoded block");
  988.     if (currentCoded->sequence == -1)
  989.     {
  990.         if (currentCoded->beginFlag || currentCoded->endFlag)
  991.         {
  992.             if (currentCoded->beginFlag)
  993.                 strcat (mybuf, ", begin block");
  994.             if (currentCoded->endFlag)
  995.                 strcat (mybuf, ", end block");
  996.         } else
  997.             strcat (mybuf, " sequence unknown");
  998.     }        
  999.     else
  1000.     {
  1001.         sprintf (str, " %d", currentCoded->sequence);
  1002.         strcat (mybuf, str);
  1003.         if (threadList[num]->expectedNumBlocks > 0)
  1004.         {
  1005.             sprintf (str, " of %d.", threadList[num]->expectedNumBlocks);
  1006.             strcat (mybuf, str);
  1007.         }
  1008.         if (currentCoded->sequence == threadList[num]->numBlocksWritten + 1)
  1009.             strcat (mybuf, " In sequence");
  1010.         else
  1011.             strcat (mybuf, " Out of sequence");
  1012.     }
  1013.     UpdateThreadStatus (num, mybuf);
  1014.     thisNumBlocks = -1;
  1015.  
  1016.     return (SUCCESS);
  1017. }
  1018.  
  1019. /* ------------------------------------------------------------------------
  1020.  *     Insert/delete a block in a thread list
  1021.  *    Inserts and deletes will be O(n).  Since n will never be big,
  1022.  *    it's not worth the trouble (and space usage) of using a linked list
  1023.  *
  1024.  *    index should never be -1 (case of unkown sequence handled by caller)
  1025.  *    to insert at front of list, index = 0
  1026.  *    to insert at end of list, index = threadList[num]->numBlocks
  1027.  */
  1028. void
  1029. InsertBlockInThread (int num, TypCoded *block, int index)
  1030. {
  1031.     register int i;
  1032.     
  1033.     for (i = threadList[num]->numBlocks; i > index && i > 0 ; i--)
  1034.         threadList[num]->codedBlockList[i] = threadList[num]->codedBlockList[i-1];
  1035.      
  1036. #ifdef DEBUG_DECODE
  1037.     sprintf(debug, "\nInserting into thread %s at posn %d", threadList[num]->ident, i);
  1038.     DebugLog(); 
  1039. #endif
  1040.      threadList[num]->codedBlockList[i] = block;
  1041.             
  1042.     threadList[num]->numBlocks++;        
  1043.  
  1044.     return;
  1045. }
  1046.  
  1047. void
  1048. DeleteBlockFromThread (int num, int index)
  1049. {
  1050.     register int i;
  1051.     
  1052.     for (i = index; i < threadList[num]->numBlocks; i++)
  1053.         threadList[num]->codedBlockList[i] = threadList[num]->codedBlockList[i+1];
  1054.      
  1055. #ifdef DEBUG_DECODE
  1056.     sprintf(debug, "\nRemoved from thread %s at posn %d", threadList[num]->name, index);
  1057.     DebugLog();
  1058. #endif
  1059.     threadList[num]->numBlocks--;        
  1060.  
  1061.     return;
  1062. }
  1063.  
  1064. /* ------------------------------------------------------------------------
  1065.  *     Complete a decode block
  1066.  *    Adds to thread list
  1067.  *    Writes block to disk if possible (and any others now in sequence)
  1068.  *    If it ends a thread, make sure everything is written, and
  1069.  *    free up the thread
  1070.  */
  1071. BOOL
  1072. CompleteThisDecode ()
  1073. {
  1074.     char mybuf[MAXINTERNALLINE];
  1075.     int num, singleBlockDone, foundEnd;
  1076.  
  1077.     UpdateBlockStatus ();    // final size displayed
  1078. #ifdef DEBUG_DECODE
  1079.     sprintf(debug, "\nCompleteThisDecode for file %s, block %d",
  1080.             currentCoded->ident, currentCoded->sequence);
  1081.     DebugLog();
  1082. #endif
  1083.     if (currentCoded->numBytes == 0)
  1084.     {
  1085. #ifdef DEBUG_DECODE
  1086.         sprintf(debug, "\nNon-data block.  Discarding it.");
  1087.         DebugLog();
  1088. #endif
  1089.         DestroyCodedBlock (¤tCoded);
  1090.         return (SUCCESS);
  1091.     }
  1092.     
  1093.     if (DumbDecode)
  1094.     {        
  1095.         if (numDumbDecoded == 0 && !currentCoded->beginFlag)
  1096.             return (SUCCESS); // Dumb skipping a data block
  1097.         if (numDumbDecoded > 0 && currentCoded->beginFlag)
  1098.         {        // found next begin without an end
  1099.             if (CodingStatusVerbose)
  1100.                 sprintf (mybuf, "Decode missing end, total size %ld, wrote to file %s", threadList[num]->totalBytes, threadList[num]->dosFileName);
  1101.             else
  1102.                 sprintf (mybuf, "%s   Decode missing end, total size %ld, wrote to file %s", 
  1103.             threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  1104.             UpdateThreadStatus (num, mybuf);
  1105.             DestroyThread(num);
  1106.             numDumbDecoded = 0;
  1107.         }
  1108.     }                    
  1109.         else
  1110.     // if for some reason (?) we didn't get a begin, but this is block 1
  1111.     if (currentCoded->sequence == 1 && 
  1112.         currentCoded->seqConfidence == HIGH && 
  1113.         !currentCoded->beginFlag)
  1114.     {
  1115.         currentCoded->beginFlag;
  1116.         strcpy (currentCoded->name, currentCoded->ident);
  1117.     }    
  1118.     
  1119.     if (AddToThreadList () == FAIL)
  1120.         return (FAIL);
  1121.     
  1122.     prevContentEncoding = thisContentEncoding;
  1123.     thisContentEncoding = CODE_UNKNOWN;
  1124.     
  1125.     num = currentDecodeThread;    
  1126.     singleBlockDone = currentCoded->beginFlag && currentCoded->endFlag;
  1127.  
  1128.     if (!CodingStatusVerbose && 
  1129.        (threadList[num]->numBlocksWritten == 0 && threadList[num]->numBlocks == 1))
  1130.     {
  1131.         sprintf (mybuf, "%s   Decode in progress", (threadList[num]->name[0]!='\0')?threadList[num]->name:threadList[num]->ident);
  1132.         UpdateThreadStatus (num, mybuf);
  1133.     }
  1134.     
  1135.     if (DumbDecode)
  1136.     {
  1137.         if (WriteTopBlockToFile (num, &foundEnd) == FAIL)
  1138.             return (FAIL);
  1139.         numDumbDecoded++;
  1140.     }
  1141.         else
  1142.         {
  1143. /* If this block is both begin and end, then go straight to WriteDecodeThread
  1144.  * If currentCoded is in sequence, then it was added as block 0 in the 
  1145.  * thread's block list, and may have caused other blocks to now be in 
  1146.  * sequence as well.  Write all blocks which are in sequence now.
  1147.  */
  1148.       if (!singleBlockDone && currentCoded->sequence != -1 && 
  1149.           currentCoded->seqConfidence != 0)
  1150.         while (threadList[num]->numBlocks != 0)
  1151.         {
  1152.             if (threadList[num]->codedBlockList[0]->sequence == threadList[num]->numBlocksWritten)
  1153.             {    // skip duplicate block sequence
  1154.                 DestroyCodedBlock (¤tCoded);    // threadList[num]->codedBlockList[0]
  1155.                             DeleteBlockFromThread (num, 0);
  1156.                             break;
  1157.                     }
  1158.             if (threadList[num]->codedBlockList[0]->sequence != threadList[num]->numBlocksWritten + 1)
  1159.                 break;
  1160. #ifdef DEBUG_DECODE
  1161.             sprintf(debug, "\nBlock in sequence, writing it, file %s, block %d",
  1162.                 threadList[num]->name, threadList[num]->codedBlockList[0]->sequence);
  1163.             DebugLog();
  1164. #endif
  1165.             if (WriteTopBlockToFile (num, &foundEnd) == FAIL)
  1166.                 return (FAIL);
  1167.          }
  1168.      }    
  1169.     if (singleBlockDone || (foundEnd && DumbDecode) ||
  1170.         (foundEnd && threadList[num]->expectedNumBlocks > 0 && 
  1171.         threadList[num]->numBlocksWritten >= threadList[num]->expectedNumBlocks))
  1172.     {
  1173. #ifdef DEBUG_DECODE
  1174.         sprintf(debug, "\nThread complete: file %s", threadList[num]->name);
  1175.         DebugLog();
  1176. #endif
  1177.            if (WriteDecodeThread(num) == FAIL)
  1178.         {
  1179.             DestroyThread(num);
  1180.             currentCoded = NULL;
  1181.                return (FAIL);
  1182.            }
  1183.  
  1184.         if (CodingStatusVerbose)
  1185.             sprintf (mybuf, "Decode complete, total size %ld, wrote to file %s", threadList[num]->totalBytes, threadList[num]->dosFileName);
  1186.         else
  1187.             sprintf (mybuf, "%s   Decode complete, total size %ld, wrote to file %s", 
  1188.         threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  1189.         UpdateThreadStatus (num, mybuf);
  1190.  
  1191.         DestroyThread(num);
  1192.         numDumbDecoded = 0;
  1193.     }
  1194.     currentCoded = NULL;
  1195.     return (SUCCESS);
  1196. }            
  1197.             
  1198. /* ------------------------------------------------------------------------
  1199.  *     Write data for the top block of a thread to a file, and remove
  1200.  *    the top block from the thread
  1201.  */
  1202. BOOL
  1203. WriteTopBlockToFile (int num, int *endFlag)
  1204. {
  1205.     char mybuf[MAXINTERNALLINE];
  1206.  
  1207.     if (WriteBlockToFile (num, threadList[num]->codedBlockList[0]) == FAIL)
  1208.     {
  1209.         sprintf (mybuf, "Could not write to file %s", threadList[num]->dosFileName);
  1210.         UpdateThreadStatus (num, mybuf);
  1211.         DestroyThread(num);
  1212.         return (FAIL);
  1213.     }
  1214.     
  1215.     *endFlag = threadList[num]->codedBlockList[0]->endFlag;
  1216.     DestroyCodedBlock (&(threadList[num]->codedBlockList[0]));
  1217.     DeleteBlockFromThread (num, 0);
  1218.     threadList[num]->numBlocksWritten++; 
  1219.     return (SUCCESS);
  1220. }
  1221.     
  1222. /* ------------------------------------------------------------------------
  1223.  *     Write data for a thread to a file
  1224.  */
  1225. BOOL
  1226. WriteDecodeThread (int num)
  1227. {
  1228.     register int i;
  1229.     char mybuf[MAXINTERNALLINE];
  1230.         
  1231.     for (i = 0; i < threadList[num]->numBlocks; i++)
  1232.     {
  1233. #ifdef DEBUG_DECODE
  1234.         sprintf(debug, "\nSaving sequence %d", threadList[num]->codedBlockList[i]->sequence);
  1235.         DebugLog();
  1236. #endif
  1237.         if (WriteBlockToFile (num, threadList[num]->codedBlockList[i]) == FAIL)
  1238.         {
  1239.             sprintf (mybuf, "Could not write to file %s", threadList[num]->dosFileName);
  1240.             UpdateThreadStatus (num, mybuf);
  1241.             return (FAIL);
  1242.         }
  1243.     }
  1244.     if (ExecuteDecodedFiles)
  1245.         ExecuteDecodedFile(num, threadList[num]->dosFileName);
  1246.  
  1247.     return (SUCCESS);
  1248. }
  1249.  
  1250. /* ------------------------------------------------------------------------
  1251.  *     Write block data to a file
  1252.  *    Verify thread file name will work in DOS, and request a new file
  1253.  *    name if necessary
  1254.  *     Accepts handle of parent window to allow any necessary dialogs
  1255.  */
  1256. BOOL
  1257. WriteBlockToFile(int num, TypCoded *thisDecode)
  1258. { 
  1259.     register unsigned long i;
  1260.     unsigned int chunkSize;
  1261.     char    actualFileName[MAXFILENAME], mybuf[MAXINTERNALLINE];
  1262.         OFSTRUCT outFileStruct;
  1263.     HFILE     hWriteFile;
  1264.     UINT    fileMode;
  1265.  
  1266. #define    CHUNK_SIZE 65500    /* must not exceed UINT (65534) */        
  1267.     
  1268.     if (threadList[num]->dosFileName[0] != '\0') {
  1269.         fileMode = OF_WRITE;
  1270.         if (strchr (threadList[num]->dosFileName, '\\') == NULL)
  1271.         {
  1272.             strcpy (actualFileName, DecodePathName);
  1273.             if (actualFileName[strlen(actualFileName)-1] != '\\')
  1274.                 strcat(actualFileName, "\\");
  1275.             strcat(actualFileName, threadList[num]->dosFileName);
  1276.             }
  1277.         else
  1278.            strcpy (actualFileName, threadList[num]->dosFileName);
  1279.     }
  1280.     else 
  1281.     {
  1282.     /* First time write to file
  1283.      */
  1284.         fileMode = OF_CREATE;
  1285.                 
  1286.                 actualFileName[0] = '\0';
  1287.         if (threadList[num]->name[0] != '\0')
  1288.             strcpy (threadList[num]->dosFileName, threadList[num]->name);
  1289.         else if (threadList[num]->ident[0] != '\0')
  1290.             strcpy (threadList[num]->dosFileName, threadList[num]->ident);
  1291.         if (threadList[num]->dosFileName[0] != '\0')
  1292.         {
  1293.             strcpy (actualFileName, DecodePathName);
  1294.             if (actualFileName[strlen(actualFileName-1)] != '\\')
  1295.                 strcat(actualFileName, "\\");
  1296.             strcat(actualFileName, threadList[num]->dosFileName);
  1297.         }
  1298.  
  1299.         /* smart filer work */
  1300.         if (SmartFile(hCodedBlockWnd, actualFileName) == FAIL)
  1301.             return (FAIL);
  1302.  
  1303.         strcpy (threadList[num]->dosFileName, actualFileName);
  1304.     }
  1305.         
  1306.         if ((hWriteFile = OpenFile ((char far *) actualFileName, &outFileStruct, fileMode)) < 0)
  1307.     {
  1308.         MessageBox(hCodedBlockWnd, "Unable to open output file", "File Error", MB_OK|MB_ICONSTOP);
  1309.         return (FAIL);
  1310.         }
  1311.         if (fileMode == OF_WRITE)
  1312.             _llseek (hWriteFile, 0L, 2);    /* append */
  1313.             
  1314.     for (i = 0L; i < thisDecode->numBytes; i += chunkSize)
  1315.     {
  1316.                if (i + CHUNK_SIZE > thisDecode->numBytes)
  1317.                    chunkSize = (unsigned int) (thisDecode->numBytes - i);
  1318.                else
  1319.                    chunkSize = CHUNK_SIZE;
  1320.  
  1321.                if (_lwrite(hWriteFile, &(thisDecode->data[i]), chunkSize) != chunkSize)
  1322.         {
  1323.             MessageBox(hCodedBlockWnd, "Error writing to file", "File Error", MB_OK|MB_ICONSTOP);
  1324.                    _lclose(hWriteFile);
  1325.             return (FAIL);
  1326.             }
  1327.         }
  1328.  
  1329.     if (CodingStatusVerbose)
  1330.     {
  1331.         strcpy (mybuf, "     Wrote block ");
  1332.         if (thisDecode->sequence > 0)
  1333.         {
  1334.             sprintf (str, "%d ", thisDecode->sequence);
  1335.             strcat (mybuf, str);
  1336.         }
  1337. //        sprintf (str, "to file %s", threadList[num]->dosFileName);
  1338. //        strcat (mybuf, str);
  1339.         UpdateThreadStatus (num, mybuf);
  1340.     }
  1341.            _lclose(hWriteFile);
  1342.     return (SUCCESS);
  1343. }
  1344.  
  1345. /* ------------------------------------------------------------------------
  1346.  *     Decode a line in article.  Store in thisDecode
  1347.  */
  1348. int  
  1349. DecodeLine(TypCoded *thisDecode, char *line)
  1350. {
  1351.     register int i;
  1352.     static int table_count;
  1353.     char thisBlockName[MAXINTERNALLINE];
  1354.          int mode;
  1355.  
  1356.     if (strlen(line) == 0)    
  1357.         return (SUCCESS);
  1358.  
  1359.     thisDecode->numLines++;
  1360.     if (thisDecode->numLines % STATUS_UPDATE_FREQ == 0)
  1361.         UpdateBlockStatus ();
  1362.     
  1363.     switch (CodingState)
  1364.     {
  1365.     case DECODE_SKIPPING: 
  1366.         if (strlen(line) < 3)    // if we're skipping, ignore any really short line
  1367.             return (SUCCESS);
  1368.  
  1369.         // encoded UU/XX/Custom data always starts with line 
  1370.         // like 'begin <mode> <file-name>'
  1371.         if (!strncmp (line, "begin", 5) &&
  1372.             sscanf (line, "%*s %d %s", &mode, thisBlockName) == 2)
  1373.                 {
  1374. #ifdef DEBUG_DECODE
  1375.             sprintf(debug, "\nStart of new encoded file %s, mode %d", thisBlockName, mode);
  1376.             DebugLog();
  1377. #endif
  1378.             if (thisBlockName[0] != '\0')
  1379.                 strcpy (thisDecode->name, strlwr(thisBlockName));
  1380.                         else
  1381.                 strcpy (thisDecode->name, thisDecode->ident);
  1382.                                     
  1383.             thisDecode->sequence = 1;
  1384.             thisDecode->beginFlag = TRUE;
  1385. //            thisDecode->mode = mode;
  1386.  
  1387.             CodingState = DECODE_PROCESSING;
  1388.             return (SUCCESS);
  1389.         }     
  1390. /* Check for keywords in the non-data lines which may aid in describing
  1391.  * the name for this data, the sequence, a custom table, etc
  1392.  */
  1393.          else if (!DumbDecode && !_strnicmp(line, "subject:", 8))
  1394.              ParseInfoLine (thisDecode, &line[8], TRUE);
  1395.          else if (!DumbDecode && !_strnicmp(line, "summary:", 8))
  1396.             ParseInfoLine (thisDecode, &line[8], FALSE);
  1397.          else if (!DumbDecode && ParseAppSpecificLine (thisDecode, line))
  1398.             return (SUCCESS);
  1399.          else if (!strncmp(line, "table", 5))
  1400.          {    // next two lines are table
  1401.              CodingState=DECODE_GET_TABLE;
  1402.             table_count = 0;
  1403.              return (SUCCESS);
  1404.          }
  1405.                      
  1406. /*        else if (ParseMimeHeaderLine(thisDecode, line) == SUCCESS)
  1407.             return (SUCCESS);
  1408. */
  1409. /* Skipping to find new block of data.
  1410.  * Skip until a data line (a line with the correct length) is found
  1411.  */        
  1412.          else if (IsDataLine(line))
  1413.         {   
  1414. #ifdef DEBUG_DECODE
  1415.             sprintf(debug, "\nFound start of next data section", line);
  1416.             DebugLog();
  1417. #endif
  1418.                          CodingState = DECODE_PROCESSING;
  1419.                            // found good line, process it and continue processing
  1420.                            return (DecodeDataLine(thisDecode, line));
  1421.         }
  1422. #ifdef DEBUG_DECODE
  1423.         sprintf(debug, "\nskipped: %s", line);
  1424.         DebugLog();
  1425. #endif
  1426.         return (SUCCESS);        // continue skipping 
  1427.  
  1428.     case DECODE_GET_TABLE:
  1429.     // This is one of two lines containing table info
  1430.         memmove ((customTable + table_count * 32), line, 32);
  1431.  
  1432.         if (++table_count == 2)
  1433.         {
  1434. #ifdef DEBUG_MAP
  1435.             strncpy (str, customTable, 64);
  1436.             str[64]='\0';
  1437.             sprintf(debug, "\nfound table: %s", str);
  1438.             DebugLog();
  1439. #endif
  1440.             CodingState = DECODE_SKIPPING;
  1441.             if (i = CreateCodingMap (CodingMap[CODE_CUSTOM], customTable) != -1)
  1442.             {
  1443. #ifdef DEBUG_MAP
  1444.                 sprintf (debug, "Invalid decoding table in block.  Duplicate character %c.",  i);
  1445.                 DebugLog();
  1446. #endif
  1447.                 customTable[0]='\0';    // ditch the table
  1448.             } 
  1449.             else
  1450.                 thisContentEncoding = CODE_CUSTOM;
  1451.         }
  1452.         return (SUCCESS);
  1453.             
  1454.     case DECODE_PROCESSING:
  1455. /* Some encoders place an END line at end of a section, and length it like 
  1456.  * a proper encoded line
  1457.  * Make sure we catch it, don't decode it as data, and switch back to skipping
  1458.  * Note the only End statement which means End of entire file is lower case
  1459.  * "end".  The other tags are ignored, i.e. "END", "End_of_section", etc
  1460.  */
  1461.         if (!_strnicmp (line, "end", 3) || !IsDataLine(line) ||
  1462.            (bossanovaMIME && !strcmp (&line[2], thisBoundary))) // skip '--'
  1463.         {
  1464. #ifdef DEBUG_DECODE    
  1465.             sprintf(debug, "\nSwitching back to skipping\nskipped: %s", line);
  1466.             DebugLog();
  1467. #endif
  1468.             CodingState = DECODE_SKIPPING;
  1469.  
  1470. /* If we are switching back to skipping and haven't really received any
  1471.  * data yet (< about a line's worth), then the line which gave us the coding type
  1472.  * was bogus (regular text line where first char happened to = encoded line 
  1473.  * length, Here's one: 'From: marnold@@cwis.unomaha.edu (Matthew Eldon Arnold)'
  1474.  * Ditch all data so far and the current table  and reprocess
  1475.  * this line.  Note if we have a custom table, then we trust it.
  1476.  */
  1477.             if (thisContentEncoding != CODE_CUSTOM && thisDecode->numBytes < 80)
  1478.             {
  1479.                 thisDecode->numBytes = 0;
  1480.                 thisContentEncoding = CODE_UNKNOWN;
  1481. #ifdef DEBUG_DECODE    
  1482.                 sprintf(debug, "\nBogus table!  Scrapping so far, reprocessing line: %s", line);
  1483.                 DebugLog();
  1484. #endif
  1485.                 thisDecode->numLines--;
  1486.                 return (DecodeLine (thisDecode, line));
  1487.             }
  1488.             strcpy (prevBlockIdent, thisDecode->ident);
  1489.         
  1490.                    if (!strncmp (line, "end", 3))
  1491.             {
  1492.                 thisDecode->endFlag = TRUE;
  1493.                 if (thisNumBlocks == -1 && thisDecode->sequence != -1)
  1494.                     thisNumBlocks = thisDecode->sequence;
  1495. #ifdef DEBUG_DECODE
  1496.                 sprintf(debug, "\nFound end of file %s", thisDecode->ident);
  1497.                 DebugLog();
  1498. #endif
  1499.             }                    
  1500.                 return (END_BLOCK);
  1501.         }
  1502.                   return (DecodeDataLine(thisDecode, line));
  1503.     }
  1504. }
  1505.  
  1506. /* ------------------------------------------------------------------------
  1507.  *  4 to 3 line decoder
  1508.  */
  1509. BOOL    DecodeDataLine (TypCoded *thisDecode, char *line)
  1510. {
  1511.     register unsigned int i, j;
  1512.     unsigned int decodedCount, numEncoded, numDecoded, checkSum, startNum, stop;
  1513.     unsigned char buf[4], outLine[120];
  1514.     char *thisMap = CodingMap[thisContentEncoding];
  1515.     
  1516.     switch (thisContentEncoding)
  1517.     {
  1518.     case CODE_QP:
  1519.        // not implemented yet
  1520.     return (FAIL);
  1521.     
  1522.     case CODE_UU:
  1523.     case CODE_XX:
  1524.     case CODE_CUSTOM:
  1525.     // these are 4-to-3 decodings which have the line length encoded
  1526.     // as the first char (count is # of chars after decoding)
  1527.     checkSum = decodedCount = thisMap[line[0]];
  1528.     numEncoded = 4 * ((thisMap[line[0]] + 2) / 3);    // don't include count char
  1529.     startNum = 1;
  1530.     break;
  1531.     case CODE_BASE64:
  1532.     // base64 is 4-to-3 decoding with nonexplicit line lengths 
  1533.     numEncoded = strlen(line);
  1534.     decodedCount = 3 * (numEncoded / 4);
  1535.     startNum = 0;
  1536.     break;
  1537.     }    
  1538.     for (i = startNum, numDecoded=0; numDecoded < decodedCount;)
  1539.     {
  1540.     // Get the next group of four characters 
  1541.     // Handle last group of characters in a base64 encoding specially -
  1542.     // padding '=' at end means we have fewer than 24 bits after decoding
  1543.     // Base64 end scenarios:
  1544.     //    'xx==' decodes to 8 bits
  1545.     //    'xxx=' decodes to 16 bits
  1546.     //    'xxxx' decodes to 24 bits
  1547.     //    'x===' can't happen
  1548.     stop = min(4, numEncoded - i + 1);
  1549.     for (j = 0; j < stop; j++, i++)
  1550.     {       
  1551.         if (thisContentEncoding == CODE_BASE64 && line[i] == '=')
  1552.         {
  1553.             buf[j] = 0;
  1554.             j--;
  1555.             break;
  1556.         }
  1557.         else
  1558.             buf[j] = thisMap[line[i]];
  1559.         checkSum += buf[j]; 
  1560.     }
  1561.     outLine[numDecoded++] = buf[0]<<2|buf[1]>>4;
  1562.     if (j == 1) break;
  1563.     outLine[numDecoded++] = buf[1]<<4|buf[2]>>2;
  1564.     if (j == 2) break;
  1565.     outLine[numDecoded++] = buf[2]<<6|buf[3];
  1566.     }
  1567.     if (numDecoded && AddDataToBlock (currentCoded, outLine, numDecoded) == FAIL)
  1568.     return (FAIL);
  1569.  
  1570. /*    if (checkSum%64 != line[i])
  1571.     {
  1572.         printf("\nChecksum error: %d vs. %d", checkSum%64, line[i]);
  1573.         break;
  1574.     } else
  1575.         printf("\nChecksum ok: %c vs. %c", checkSum%64, line[i]);
  1576. */
  1577.     return (SUCCESS);
  1578. }
  1579.  
  1580. /* ------------------------------------------------------------------------
  1581.  * AddDataToBlock is called on a line-by-line basis.
  1582.  * dataLen should rarely be > 100 bytes
  1583.  * The data is type huge, but it's just pointing to a string of chars, so
  1584.  * the size does not have to be a power of 2
  1585.  */
  1586. BOOL
  1587. AddDataToBlock (TypCoded *thisDecode, char *newData, unsigned int dataLen)
  1588. {
  1589.     if (thisDecode->numBytes + (unsigned long) dataLen > thisDecode->maxBytes)
  1590.     { 
  1591.             thisDecode->maxBytes += BASE_BLOCK_SIZE;
  1592. #ifdef DEBUG_MEM
  1593.         sprintf(debug, "\nReallocing data to %ld", thisDecode->maxBytes);
  1594.         DebugLog();
  1595. #endif
  1596.         if ((thisDecode->data = (char huge *) GlobalReAllocPtr (thisDecode->data, thisDecode->maxBytes, GMEM_MOVEABLE)) == NULL)    
  1597.             return (FALSE);
  1598.     }
  1599.     memmove (thisDecode->data + thisDecode->numBytes, newData, dataLen);
  1600.     thisDecode->numBytes += dataLen;
  1601.         return (SUCCESS);
  1602. }     
  1603.         
  1604. /* ------------------------------------------------------------------------
  1605.  *     Determine if the line is a data line
  1606.  */
  1607. BOOL
  1608. IsDataLine (char *line)
  1609. {
  1610.     if (thisContentEncoding == CODE_UNKNOWN)
  1611.     {
  1612. /* If this block has same ident as prev block, use same decode table
  1613.  * If this block has same ident as any existing threads, use same decode table
  1614.  * as matching thread
  1615.  * Otherwise, test line for UU, XX, or Base64, returning if find a fit
  1616.  */            
  1617.         if (currentCoded->ident[0] != '\0' && 
  1618.             !strcmp (currentCoded->ident, prevBlockIdent))
  1619.         {
  1620.             thisContentEncoding = prevContentEncoding;
  1621. #ifdef DEBUG_MAP
  1622.             strcpy (debug, "\nUsing same table as prev decode block");
  1623.             DebugLog();
  1624. #endif
  1625.         }
  1626.         else
  1627.             if ((thisContentEncoding = ThreadTable (customTable, currentCoded->ident)) != CODE_UNKNOWN)
  1628.             {
  1629.                if (thisContentEncoding == CODE_CUSTOM)
  1630.                 CreateCodingMap (CodingMap[CODE_CUSTOM], customTable);
  1631. #ifdef DEBUG_MAP
  1632.                 strcpy (debug, "\nUsing stored thread table");
  1633.                 DebugLog();
  1634. #endif
  1635.             }
  1636.             else
  1637.             {                
  1638.                 thisContentEncoding = CODE_UU;
  1639.                 if (TestDataLine (line))
  1640.                 {
  1641. #ifdef DEBUG_MAP
  1642.                     sprintf (debug, "\nUsing UU table: %s", line);
  1643.                     DebugLog();
  1644. #endif
  1645.                     return (TRUE);
  1646.                 }
  1647.                 thisContentEncoding = CODE_XX;
  1648.                 if (TestDataLine (line))
  1649.                 {
  1650. #ifdef DEBUG_MAP
  1651.                     sprintf (debug, "\nUsing XX table: %s", line);
  1652.                     DebugLog();
  1653. #endif
  1654.                     return (TRUE);
  1655.                 }
  1656.                 thisContentEncoding = CODE_BASE64;
  1657.                 if (TestDataLine (line))
  1658.                 {
  1659. #ifdef DEBUG_MAP
  1660.                     sprintf (debug, "\nUsing Base64 table: %s", line);
  1661.                     DebugLog();
  1662. #endif
  1663.                     return (TRUE);
  1664.                 }
  1665.                 thisContentEncoding = CODE_UNKNOWN;
  1666.                 return (FALSE);
  1667.             }
  1668.     }
  1669.     return (TestDataLine(line));
  1670. }
  1671.         
  1672. BOOL
  1673. TestDataLine (char *line)
  1674. {        
  1675.    unsigned int expectedLineLen, dataLen, lineLen;
  1676.    register unsigned int i;
  1677.    char *thisMap;
  1678.    
  1679.    thisMap = CodingMap[thisContentEncoding];
  1680.    lineLen = strlen(line);
  1681.    switch (thisContentEncoding)
  1682.    {
  1683.    case CODE_UU:
  1684.    case CODE_XX:
  1685.    case CODE_CUSTOM:
  1686. /*
  1687.  * The first char of a good data UU/XX/Custom line is the encoded character
  1688.  * count for the line.  
  1689.  * example M = ascii 77, decodes to 45.  This line will decode to 45 characters,
  1690.  * so the # encoded chars should be (int)(4 * ((n+2) / 3)) - (round up and re-encode)
  1691.  * So if line[0] is 'M', there should be 60 characters on the line
  1692.  * The count does not include the first count char, so the expected line 
  1693.  * length is count+1 (i.e. 61). 
  1694.  * If the line length is actually 2 + count, then we have a checksum (?)
  1695.  */ 
  1696.     expectedLineLen = 4 * ((thisMap[line[0]] + 2) / 3) + 1;
  1697.  
  1698.     if (lineLen < expectedLineLen)
  1699.          return (FALSE);
  1700. /*
  1701.  * Count the number of encoded data characters on the line (up to any whitespace)
  1702.  * (Some encoders pad with spaces at the end).  Don't forget, a space may be
  1703.  * a valid encoded char, so a proper line may very well end with a space.
  1704.  * Don't blindly remove all trailing white space!
  1705.  */        
  1706.      for (dataLen = lineLen; 
  1707.           isspace (line[dataLen-1]) && dataLen > 0 && dataLen != expectedLineLen; 
  1708.           --dataLen);
  1709.      
  1710.      // May have a checksum character, so allow for one extra char
  1711.      if (expectedLineLen != dataLen && expectedLineLen+1 != dataLen)
  1712.          return (FALSE);
  1713.      
  1714.      line[dataLen] = '\0';    // permanently chop off the white space
  1715.      // It's the right length, now check content for match w/ table
  1716.     for (i = 0; i < expectedLineLen; i++)
  1717.         if (thisMap[line[i]] == UNUSED)
  1718.             return (FALSE);
  1719.     return (TRUE);
  1720.  
  1721.     case CODE_BASE64:
  1722.     // permanently remove all trailing space
  1723.     while (lineLen > 0 && isspace (line[lineLen-1]))
  1724.         line[--lineLen] = '\0';
  1725.      
  1726.      // for base 64, just check if all chars in coding map (allow pad '=')
  1727.     for (i = 0; i < lineLen; i++)
  1728.         if (thisMap[line[i]] == UNUSED && line[i] != '=')
  1729.             return (FALSE);
  1730.     return (TRUE);
  1731.  
  1732.     case CODE_QP:
  1733.     // not implemented yet
  1734.     default:
  1735.         return (FALSE);
  1736.     }        
  1737. }                               
  1738.  
  1739. /* ------------------------------------------------------------------------
  1740.  *     Mappings for encoding/decoding
  1741.  */
  1742. int
  1743. CreateCodingMap(char *map, char *table)
  1744. {
  1745.     register unsigned int i;
  1746.     
  1747.     for (i=0; i < 128; i++)
  1748.         map[i] = UNUSED;
  1749.     
  1750.     // if you see a table[i] character, decode it to i
  1751.     // i.e. UU, table[1] is a '!'.  So a '!' should decode to 1
  1752.     
  1753.     for (i = 0; i < CODINGTABLESIZE; i++)
  1754.             if (map[table[i]] != UNUSED)
  1755.                 return (table[i]);    // table[i] is duplicate 
  1756.         else                
  1757.             map[table[i]]=i;
  1758.     
  1759. #ifdef DEBUG_MAP2
  1760.     sprintf(debug, "\nCoding Map:\n"); DebugLog();
  1761.     for (i=0; i < 128; i++)
  1762.     {
  1763.         sprintf(debug, "%d ",map[i]);
  1764.         DebugLog();
  1765.     } 
  1766. #endif
  1767.     return (-1);            
  1768. }
  1769.  
  1770. int   
  1771. ThreadTable (char *dest, char *ident)
  1772. {
  1773.     int num;
  1774.     register int i;
  1775.     
  1776.     for (num = -1, i = 0; i < numDecodeThreads; i++)
  1777.         if (!_stricmp (ident, threadList[i]->ident))
  1778.             num = i;
  1779.  
  1780.     if (num == -1)        // no thread by that name 
  1781.         return (CODE_UNKNOWN);
  1782.     else
  1783.     {
  1784.         if (threadList[num]->contentEncoding == CODE_CUSTOM)
  1785.             strncpy (dest, threadList[num]->customTable, CODINGTABLESIZE);
  1786.         return (threadList[num]->contentEncoding);
  1787.     }
  1788. }
  1789. #if 0
  1790. void
  1791. CreateUUTable()
  1792. {
  1793.     register unsigned int i;
  1794.  
  1795.     for (i=0; i < CODINGTABLESIZE; i++)
  1796.         uuTable[i] = i + 32;
  1797.     
  1798.     uuTable[0] = 96;        /* set space to map to back-quote */    
  1799. }
  1800. #endif
  1801.  
  1802. /* ------------------------------------------------------------------------
  1803.  *    Search through a subject: or BEGIN line 
  1804.  *    (for a Subject: line,  "Subject:" has already been removed).
  1805.  *
  1806.  *    Attempt to obtain a block number, and a total # of blocks
  1807.  *    Generate an identifier based on the subject, preferably based on the
  1808.  *    actual file name.  If guessIdent is TRUE, choose an ident even if
  1809.  *    it doesn't look like a fileName.  If guessIdent is FALSE, only fill
  1810.  *    ident if we see a fileName (word containing a dot).
  1811.  *
  1812.  *    Note: at this point, we haven't seen any MIME header, and we're not
  1813.  *    really expecting one.  So now is the time to get what we can
  1814.  *
  1815.  *    Common Subject styles which this function deals with:
  1816.  *    filename.ext 1/2 comment
  1817.  *    filename.ext(1/2)comment
  1818.  *    filename.ext (1/2) comment
  1819.  *    filename.ext [1/2] comment
  1820.  *    filename.ext 1 of 2 comment
  1821.  *    filename.ext part 1 of 2 comment
  1822.  *    filename.ext 1 of 2 comment
  1823.  *    This is part 1/2 of filename.ext
  1824.  *
  1825.  *    Also handles the following common BEGIN lines:
  1826.  *    BEGIN --- CUT HERE --- Cut Here --- cut here --- abcd.efg n/N
  1827.  *     BEGIN --- CUT HERE --- Cut Here --- cut here --- abcd.efg
  1828.  *    BEGIN-------cut here-------CUT HERE-------PART n               // This is TIN
  1829.  *    BEGIN -- CUT HERE -- cut here -- abcd.efg part n of N
  1830.  *    BEGIN---CUT HERE---BEGIN---CUT HERE---BEGIN PART n/N
  1831.  *
  1832.  *    For subject lines beginning with the comment, or free text, the
  1833.  *    name is harder to guess.  In these cases, prefer a word containing
  1834.  *    a dot (filename.ext), or if none, just take the first word.  Scan
  1835.  *    any existing threads to see if any of their identifiers matches.
  1836.  *    For example,
  1837.  *    another encoded file: filename.ext (1/2)
  1838.  *    testing encoded files (1/2)    i.e. ident would be testing
  1839.  *
  1840.  *     Known to be incorrectly handled by this function:
  1841.  *    filename.ext 3.4 (1/2)        i.e. name w/ version number
  1842.  *    filename.ext 001        i.e. sequence w/ no # parts
  1843.  *    filename.ext1            i.e. part number appended to file name
  1844.  */ 
  1845. #define SEEK_PARTNUM    1
  1846. #define SEEK_NUMPARTS    2
  1847. #define IGNORE_NUMBERS    3
  1848. void
  1849. ParseInfoLine (TypCoded *thisDecode, char *line, BOOL guessIdent)
  1850. {
  1851.     char tok[MAXINTERNALLINE], next[MAXINTERNALLINE];
  1852.     char guessName[MAXINTERNALLINE];
  1853.     char *ptr, *thisTok, *tmp;
  1854.     int  numberMode;
  1855.     
  1856.     numberMode = SEEK_PARTNUM;
  1857.     ptr = line;
  1858.         
  1859.     guessName[0] = '\0';
  1860.         while (*ptr)
  1861.         {
  1862.             if (ReadSubjectToken (thisTok = tok, &ptr) == NULL)
  1863.                 break;
  1864.         
  1865. //    NUMBERS
  1866.         if (numberMode != IGNORE_NUMBERS)
  1867.            if (isnumber (thisTok))
  1868.            {
  1869.             if (numberMode == SEEK_PARTNUM)
  1870.             {
  1871.                 thisDecode->sequence = atoi (thisTok);
  1872.                 thisDecode->seqConfidence = LOW;
  1873.  
  1874.                 if (ReadSubjectToken (next, &ptr) == NULL)
  1875.                     break;
  1876.                 if (!_stricmp (next, "/") ||
  1877.                     !_stricmp (next, "of"))
  1878.                 {
  1879.                     numberMode = SEEK_NUMPARTS;        
  1880.                     continue;
  1881.                 }
  1882.                 else    // no numParts immediately following
  1883.                     thisTok = next;    // process the next tok
  1884.             }
  1885.             else    // numberMode == SEEK_NUMPARTS
  1886.             {
  1887.                 thisNumBlocks = atoi (tok);
  1888.                 numberMode = IGNORE_NUMBERS;
  1889.                 thisDecode->seqConfidence = HIGH;
  1890.                     continue;
  1891.             }
  1892.            }
  1893.            else if (numberMode == SEEK_NUMPARTS)
  1894. //           We had '# of non#', a red herring, seek again
  1895.             numberMode == SEEK_PARTNUM;
  1896.             
  1897. //    WORDS
  1898.         // Prefer a word containing a dot for the ident (but not a period
  1899.         // at the end of a sentence
  1900.             if ((tmp = strchr (thisTok, '.')) && isalpha(*(tmp+1)))
  1901.             strcpy (thisDecode->ident, thisTok);
  1902.             else if (guessIdent)
  1903.             {
  1904.                 // skip if already have name w/ confidence
  1905.                 if (thisDecode->ident[0] == '\0')
  1906.             {
  1907.             // check if any threads have this token as name
  1908.                    if (SearchThreadNames (thisTok))
  1909.                     strcpy (thisDecode->ident, thisTok);
  1910.  
  1911.             // Save first word found for thread name
  1912.             // prefer ident not starting with 're'
  1913.                    else if (guessName[0] == '\0' || !_strnicmp(guessName, "re", 2))
  1914.                     strcpy (guessName, thisTok);
  1915.                 }
  1916.             }
  1917.     }
  1918.     if (guessIdent && thisDecode->ident[0] == '\0')
  1919.         strcpy (thisDecode->ident, guessName);
  1920.  
  1921. #ifdef DEBUG_DECODE
  1922.     sprintf(debug, "\nSubject header: name %s, part number %d (confidence %d), num parts %d", 
  1923.         thisDecode->ident, thisDecode->sequence, thisDecode->seqConfidence, thisNumBlocks);
  1924.     DebugLog();
  1925. #endif
  1926. }
  1927.  
  1928. char *
  1929. ReadSubjectToken (char *dest, char **ptr)
  1930. {
  1931.     int len;
  1932.     register int i;
  1933.     char *str = *ptr;
  1934.     
  1935.     if (*str == '\0')
  1936.         return ('\0');
  1937.         
  1938.     len = strcspn (str, " ()[]\\/:,\"'`{};\n\r");
  1939.  
  1940. /*    Ignore (skip) all of these delimiters except '/'
  1941.  *    Return '/' as a token of length 1
  1942.  */                      
  1943.     if (len == 0)
  1944.         if (*str == '/')
  1945.             len = 1;
  1946.         else
  1947.         {    // skip this delimiter
  1948.             (*ptr)++;
  1949.             return (ReadSubjectToken (dest, ptr));
  1950.         }
  1951.  
  1952.         for (i = 0; i < len; i++)
  1953.             dest[i] = tolower(str[i]);
  1954.         dest[len] = '\0';
  1955.  
  1956.     *ptr = str + len;    // increment line ptr    
  1957. }
  1958.  
  1959. BOOL
  1960. SearchThreadNames (char *name)
  1961. {
  1962.     register int i;
  1963.     int len;
  1964.     
  1965.     len = strlen (name);
  1966.  
  1967.     for (i = 0; i < numDecodeThreads; i++)
  1968.         if (!_strnicmp (name, threadList[i]->ident, len))
  1969.             return (TRUE);
  1970.  
  1971.     return (FALSE);
  1972. }
  1973.  
  1974. /* ParseAppSpecificLine
  1975.  * returns TRUE if it handles the line, else FALSE
  1976.  *
  1977.  * Example info lines handled by this function:
  1978.  *    part=n
  1979.  *    file=abc.def
  1980.  *    pfile=xyz.abc 
  1981.  *    Archive-name: fileident/part0n        // no extension included for filename
  1982.  *
  1983.  *     section N of uuencode 5.10 of file abcd.efg   by R.E.M.
  1984.  *    section n/N   file abcd.efg   [ Wincode v2.3 ]
  1985.  *    [ Section: n/N  File: abcd.efg  Encoder: Wincode v1.4 ]
  1986.  *    section n/N abcd.efg  [EnUU 2.1]
  1987.  *  abcd.efg    section  n/N   UUXFER ver 2.0 by David M. Read
  1988.  *    POST V2.0.0 abcd.efg (Part n/N)
  1989.  */
  1990. BOOL
  1991. ParseAppSpecificLine (TypCoded *thisDecode, char *line)
  1992. {
  1993.     char *orig, *ptr;
  1994.     int seq, num, len;
  1995.     float ver;
  1996.     char name[MAXINTERNALLINE];
  1997.     char copy[MAXINTERNALLINE];
  1998.     
  1999.        for (orig = line; *orig && isspace(*orig); orig++);    // skip leading spaces
  2000.     
  2001.     if (*orig == '\0')            // blank line (or all spaces)
  2002.             return (SUCCESS);
  2003.  
  2004.     len = min(MAXINTERNALLINE-1, strlen(orig));
  2005.     strncpy (copy, orig, len);    // make a lower-case copy
  2006.     copy[len] = '\0';
  2007.     strlwr(copy);
  2008.     
  2009.     if (!strncmp(orig, "BEGIN", 5))    // specifically comparing case-sensitive
  2010.     {
  2011.         ParseInfoLine(thisDecode, copy, FALSE);
  2012.         return (TRUE);
  2013.     }
  2014.  
  2015.     if (sscanf(copy, "file=%s", name) == 1)
  2016.     {
  2017.         strcpy (thisDecode->ident, name);
  2018.         return (TRUE);
  2019.     }
  2020.  
  2021.     if (*copy == 'p')    // info headers starting with 'p'
  2022.     {
  2023.         if (sscanf(copy, "part=%d", &seq) == 1)
  2024.         {
  2025.             thisDecode->sequence = seq;
  2026.             if (!thisDecode->seqConfidence)
  2027.                 thisDecode->seqConfidence = LOW; // still don't have number of parts
  2028.             return (TRUE);
  2029.         }
  2030.         if (sscanf(copy, "pfile=%s", name) == 1)
  2031.         {
  2032.             strcpy (thisDecode->ident, name);
  2033.             return (TRUE);
  2034.         }
  2035.         /* POST */
  2036.         if (sscanf (copy, "POST V%*s %s (Part %d/%d)", name, &seq, &num) == 3)
  2037.         {
  2038.             thisDecode->sequence = seq;
  2039.             thisNumBlocks = num;
  2040.             thisDecode->seqConfidence = HIGH;
  2041.             strcpy (thisDecode->ident, name);
  2042.             return (TRUE);
  2043.         }
  2044.         return (FALSE);    // started with 'p' but we didn't have a template
  2045.     }
  2046.  
  2047.     /* note some of these look for a version number, then don't use it.  the
  2048.        version number is scanned simply to add to our confidence that this is
  2049.        a valid info line.  we want it to be included in the count - so we know
  2050.        if the line fits the template (hence don't use %*f)
  2051.     */
  2052.  
  2053.     /* R.E.M., EnUU, and WinCode v2.x all start with "section " */
  2054.     if (!strncmp(copy, "section", 7))
  2055.     {
  2056.         ptr = ©[7];
  2057.         /* R.E.M. */
  2058.         if (sscanf (ptr, " %d of uuencode %f of file %s", &seq, &ver, name) == 3)
  2059.         {    
  2060.             thisDecode->sequence = seq;
  2061.             if (!thisDecode->seqConfidence)
  2062.                 thisDecode->seqConfidence = LOW; // still don't have number of parts
  2063.                     
  2064.             strcpy (thisDecode->ident, name);
  2065.             thisContentEncoding = CODE_UU;
  2066.             return (TRUE);
  2067.         }
  2068.          /* EnUU */
  2069.          if (sscanf (ptr, " %d/%d %s [EnUU %f]", &seq, &num, name, &ver) == 4)
  2070.         {
  2071.             thisDecode->sequence = seq;
  2072.             thisNumBlocks = num;
  2073.             thisDecode->seqConfidence = HIGH; 
  2074.             strcpy (thisDecode->ident, name);
  2075.             thisContentEncoding = CODE_UU;
  2076.             return (TRUE);
  2077.         }
  2078.         /* Wincode v2.x */
  2079.         if (sscanf (ptr, " %d/%d  file %s [ Wincode v%f ]", &seq, &num, name, &ver) == 4)
  2080.         {
  2081.             thisDecode->sequence = seq;
  2082.             thisNumBlocks = num;
  2083.             thisDecode->seqConfidence = HIGH; 
  2084.             strcpy (thisDecode->ident, name);
  2085.             return (TRUE);
  2086.         }
  2087.         return (FALSE);    // started with 'section' but we didn't have a template
  2088.     }
  2089.     /* Wincode v1.x */
  2090.     if (sscanf (copy, "[ section: %d/%d  File: %s  Encoder: Wincode v%f", &seq, &num, &ver) == 4)
  2091.     {
  2092.         thisDecode->sequence = seq;
  2093.         thisNumBlocks = num;
  2094.         thisDecode->seqConfidence = HIGH; 
  2095.         strcpy (thisDecode->ident, name);
  2096.         return (TRUE);
  2097.     }
  2098.  
  2099.     /* UUXFER */
  2100.     if (sscanf (copy, "%s section %d/%d  UUXFER ver %f", name, &seq, &num, &ver) == 4)
  2101.     {    
  2102.         thisDecode->sequence = seq;
  2103.         thisNumBlocks = num;
  2104.         thisDecode->seqConfidence = HIGH; 
  2105.         strcpy (thisDecode->ident, name);
  2106.         thisContentEncoding = CODE_UU;
  2107.         return (TRUE);
  2108.     }
  2109.  
  2110.     if (sscanf(copy, "archive-name: %[^/]/part%d", name, &seq) == 2)        // %[^/] reads a string up to a slash
  2111.     {
  2112.         strcpy (thisDecode->ident, name);
  2113.         thisDecode->sequence = seq;
  2114.         if (!thisDecode->seqConfidence)
  2115.             thisDecode->seqConfidence = LOW; // still don't have number of parts
  2116.         return (TRUE);
  2117.     }
  2118.  
  2119.     return (FALSE);
  2120. }
  2121. //-------------------------------------------------------------------------
  2122. void
  2123. ExecuteDecodedFile(int num, char *fileName)
  2124. {
  2125.     char ext[4];        // these are DOS specific...
  2126. //    char name[9];
  2127.     char association[MAXINTERNALLINE];
  2128.     char execute[MAXINTERNALLINE+MAXFILENAME];
  2129.     int len;
  2130.     unsigned int err;
  2131.     char *src, *dest, *src2;
  2132.     char mybuf[MAXINTERNALLINE];
  2133.  
  2134. #ifndef WIN32
  2135.     GetFileExtension (ext, fileName);
  2136.  
  2137.         if (!_stricmp (ext, "exe"))
  2138.             strcpy (execute, fileName);
  2139.     else
  2140.     // example association: doc=C:\WIN\WINWORD\winword.exe ^.doc
  2141.  
  2142.     if ((len = GetProfileString ("Extensions", (LPCSTR)ext, "", association, MAXINTERNALLINE)) != 0)
  2143.     {
  2144.       for (src = association, dest = execute; *src; src++)
  2145.       {
  2146.         if (*src == '^')
  2147.         {
  2148.             for (src2 = fileName; *src2 && *src2 != '.'; src2++)
  2149.                *(dest++) = *src2;
  2150.         }
  2151.         else
  2152.            *(dest++) = *src;
  2153.       }
  2154.       *dest = '\0';
  2155.         }
  2156.         else
  2157.         {
  2158.         sprintf(mybuf, "Cannot execute - no association for file type %s", ext);
  2159.         UpdateThreadStatus (num, mybuf);
  2160.         return;
  2161.     }
  2162.  
  2163. #else
  2164.         FindExecutable (fileName, ".", association);
  2165.     wsprintf (execute, "%s %s", association, fileName);
  2166. #endif
  2167.     if ((err = WinExec (execute, SW_SHOWNORMAL)) < 32)
  2168.     {
  2169.         sprintf(mybuf, "Error executing %s, error %u", execute, err);
  2170.         UpdateThreadStatus (num, mybuf);
  2171.     }
  2172.     else if (CodingStatusVerbose)
  2173.     {
  2174.         sprintf(mybuf, "Executed %s", execute);
  2175.         UpdateThreadStatus (num, mybuf);
  2176.     }
  2177. }
  2178. @
  2179.  
  2180.  
  2181. 1.11
  2182. log
  2183. @new coding-status window style.  optimized info-header parser.
  2184. general cleanup for 92.6
  2185. @
  2186. text
  2187. @d37 1
  2188. a37 1
  2189.  * $Id: wvcoding.c 1.10 1994/08/24 18:00:29 jcooper Exp $
  2190. d39 4
  2191. d139 1
  2192. a350 3
  2193.     int x, y, width, height;
  2194.                                                                                                              
  2195.                                                                                                              
  2196. d353 1
  2197. d356 14
  2198. a369 5
  2199.     // Create coding status window
  2200.     width = STATUSWIDTH;
  2201.     height = STATUSHEIGHT;
  2202.     x = (xScreen - width)/2;        // center it
  2203.     y = 1;
  2204. d371 2
  2205. a372 2
  2206.             WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_DLGFRAME,
  2207.             x, y, width, height,
  2208. d378 6
  2209. d385 1
  2210. a385 1
  2211. DestroyStatusArea ()
  2212. d387 3
  2213. a389 3
  2214.     DestroyCodedBlock (¤tCoded);
  2215.     DestroyWindow (hCodedBlockWnd);
  2216.     hCodedBlockWnd = (HWND)NULL;
  2217. d391 1
  2218. d393 10
  2219. a567 1
  2220.     int x, y, width, height;
  2221. d592 1
  2222. a592 11
  2223.     width = STATUSWIDTH;
  2224.     height = STATUSHEIGHT;
  2225.     x = (xScreen - width)/2;        // center it
  2226.     y = 1;
  2227.     hCodedBlockWnd = CreateWindowEx (WS_EX_DLGMODALFRAME, "WinVnBlockCoding", "Block Decoding Status",
  2228.             WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_DLGFRAME,
  2229.             x, y, width, height,
  2230.             (HWND)NULL, (HMENU)NULL, hInst, (void far *)NULL);
  2231.  
  2232.     SetHandleBkBrush (hCodedBlockWnd, hStatusBackgroundBrush); 
  2233.     ShowWindow (hCodedBlockWnd, SW_SHOWNORMAL);
  2234. d595 1
  2235. a692 21
  2236.  *    Adds text to a thread coding status block, and refreshes
  2237.  *    the thread status window
  2238.  */    
  2239. void
  2240. UpdateThreadStatus (int num, char *str)
  2241. {
  2242.     AddLineToTextBlock (threadList[num]->statusText, str);
  2243.     InvalidateRect (threadList[num]->statusText->hTextWnd, NULL, FALSE);
  2244.     UpdateWindow (threadList[num]->statusText->hTextWnd);
  2245. }
  2246.  
  2247. /* ------------------------------------------------------------------------
  2248.  *    Refreshes the block status window
  2249.  */    
  2250. void
  2251. UpdateBlockStatus ()
  2252. {
  2253.     InvalidateRect (hCodedBlockWnd, NULL, FALSE);
  2254.     UpdateWindow (hCodedBlockWnd);
  2255. }
  2256. /* ------------------------------------------------------------------------
  2257. d706 3
  2258. d764 1
  2259. a764 1
  2260.            int x, y, width, height;
  2261. d816 1
  2262. a816 1
  2263.             if (CodingStatusVerbose || numStatusTexts == 0)
  2264. d821 1
  2265. a821 1
  2266.                    if (numStatusTexts + 1 > MAX_DECODE_THREADS);
  2267. d824 1
  2268. a824 1
  2269.                    codingStatusText[numStatusTexts++] = threadList[num]->statusText;
  2270. a825 5
  2271.            width = (int)(xScreen * 1/2);
  2272.            x = (numStatusTexts * StatusCharWidth) % (int) (xScreen * 3/4);
  2273.            height = (int) (yScreen * 1/2) - (1 * StatusLineHeight);
  2274.            y = (int) (yScreen * 1/4) + (numStatusTexts * StatusLineHeight) % (int)(yScreen * 3/4);
  2275.  
  2276. d831 8
  2277. d857 1
  2278. a857 1
  2279.            threadList[num]->statusText = codingStatusText[0];
  2280. d1024 1
  2281. a1024 1
  2282.                     threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  2283. d1109 1
  2284. a1109 1
  2285.                 threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  2286. @
  2287.  
  2288.  
  2289. 1.10
  2290. log
  2291. @misc encoding/decoding changes
  2292. @
  2293. text
  2294. @d37 1
  2295. a37 1
  2296.  * $Id: wvcoding.c 1.9 1994/08/11 21:03:19 rushing Exp $
  2297. d39 3
  2298. a66 2
  2299. #include <stdio.h>
  2300. #include <stdlib.h>
  2301. d69 3
  2302. d73 2
  2303. a75 2
  2304. #include "wvglob.h"
  2305. #include "winvn.h"
  2306. d217 2
  2307. d220 1
  2308. d223 5
  2309. a227 1
  2310.             CompleteThisDecode ();
  2311. d271 2
  2312. d274 2
  2313. d278 5
  2314. a282 1
  2315.             CompleteThisDecode ();
  2316. a290 2
  2317.     GlobalUnlock (BlockPtr->hCurBlock);
  2318.  
  2319. d295 1
  2320. d318 1
  2321. a318 1
  2322.     if (AskForNewFileName (hParentWnd, fileName, "") != FAIL)
  2323. d358 2
  2324. a359 2
  2325.     hCodedBlockWnd = CreateWindow ("WinVnBlockCoding", "Block Encoding Status",
  2326.             WS_OVERLAPPEDWINDOW|WS_MINIMIZEBOX,
  2327. d568 2
  2328. a569 2
  2329.     hCodedBlockWnd = CreateWindow ("WinVnBlockCoding", "Block Decoding Status",
  2330.             WS_OVERLAPPEDWINDOW|WS_MINIMIZEBOX,
  2331. d757 1
  2332. a757 1
  2333. BOOL
  2334. d1071 1
  2335. a1071 1
  2336.                 DestroyCodedBlock (&(threadList[num]->codedBlockList[0]));
  2337. d1097 1
  2338. d1111 1
  2339. d1216 4
  2340. a1219 2
  2341.         if (AskForNewFileName (hCodedBlockWnd, actualFileName, DecodePathName) == FAIL)
  2342.             return (FAIL);                                  
  2343. d1273 1
  2344. a1273 1
  2345.     if (strlen(line) < 2)    /* skip over short/blank lines */
  2346. d1283 5
  2347. a1287 2
  2348.     // encoded UU/XX/Custom data always starts with line 
  2349.     // like 'begin <mode> <file-name>'
  2350. d1316 1
  2351. a1316 1
  2352.          else if (!_strnicmp(line, "table", 5))
  2353. d1360 5
  2354. a1364 3
  2355.                 sprintf (str, "Invalid decoding table in block.  Duplicate character %c.",  i);
  2356.                 MessageBox (hCodedBlockWnd, str, "Invalid coding table", MB_OK);
  2357.                 return (FAIL);
  2358. d1366 2
  2359. a1367 1
  2360.             thisContentEncoding = CODE_CUSTOM;
  2361. a1432 1
  2362.     numEncoded = strlen(line);
  2363. d1442 1
  2364. a1442 1
  2365.     // these are 4-to-3 decodings which have the line lengtrh encoded
  2366. d1445 1
  2367. d1450 1
  2368. d1484 1
  2369. a1484 1
  2370.     if (AddDataToBlock (currentCoded, outLine, numDecoded) == FAIL)
  2371. d1890 1
  2372. a1890 1
  2373.         
  2374. d1894 6
  2375. a1899 1
  2376.  * Example application lines handled by this function:
  2377. d1902 1
  2378. d1904 1
  2379. a1904 1
  2380.  *      abcd.efg    section  n/N   UUXFER ver 2.0 by David M. Read
  2381. a1905 4
  2382.  *    part=n
  2383.  *    file=abc.def
  2384.  *    pfile=xyz.abc 
  2385.  *    Archive-name: fileident/part0n        // no extension included for filename
  2386. d1910 3
  2387. a1912 2
  2388.     char *orig;
  2389.     int seq, num;
  2390. d1918 1
  2391. a1918 1
  2392.     if (*orig == '\0')            // blank line (all spaces)
  2393. d1920 5
  2394. d1926 1
  2395. a1926 5
  2396.     /* note most application keywords will be compared case-sensitively
  2397.      * (using orig), but then all following info-gathering will be 
  2398.      * case-insensitive (using copy) 
  2399.      */
  2400.     if (sscanf(orig, "part=%d", &seq) == 1)
  2401. d1928 1
  2402. a1928 3
  2403.         thisDecode->sequence = seq;
  2404.         if (!thisDecode->seqConfidence)
  2405.             thisDecode->seqConfidence = LOW; // still don't have number of parts
  2406. d1931 2
  2407. a1932 1
  2408.     if (sscanf(orig, "file=%s", name) == 1)
  2409. a1936 13
  2410.     if (sscanf(orig, "pfile=%s", name) == 1)
  2411.     {
  2412.         strcpy (thisDecode->ident, name);
  2413.         return (TRUE);
  2414.     }
  2415.     if (sscanf(orig, "Archive-name: %[^/]/part%d", name, &seq) == 2)        // %[^/] reads a string up to a slash
  2416.     {
  2417.         strcpy (thisDecode->ident, name);
  2418.         thisDecode->sequence = seq;
  2419.         if (!thisDecode->seqConfidence)
  2420.             thisDecode->seqConfidence = LOW; // still don't have number of parts
  2421.         return (TRUE);
  2422.     }
  2423. d1938 1
  2424. a1938 5
  2425.     strncpy (copy, orig, MAXINTERNALLINE-1);
  2426.     copy[MAXINTERNALLINE-1] = '\0';
  2427.     AnsiLowerBuff ((LPSTR)copy, (UINT)strlen (copy));    // make a lower-case copy
  2428.  
  2429.     if (strstr(orig, "R.E.M."))
  2430. d1940 2
  2431. a1941 2
  2432.         if (sscanf (copy, "section %d of uuencode %*f of file %s", &seq, name) == 2)
  2433.         {    
  2434. d1945 4
  2435. a1948 1
  2436.                 
  2437. a1949 1
  2438.             thisContentEncoding = CODE_UU;
  2439. d1952 3
  2440. a1954 5
  2441.     }
  2442.     if (strstr(orig, "UUXFER"))
  2443.     {
  2444.         if (sscanf (copy, "%s section %d/%d", name, &seq, &num) == 3)
  2445.         {    
  2446. d1957 1
  2447. a1957 1
  2448.             thisDecode->seqConfidence = HIGH; 
  2449. a1958 1
  2450.             thisContentEncoding = CODE_UU;
  2451. d1961 1
  2452. d1963 9
  2453. a1971 1
  2454.     if (!strncmp(orig, "BEGIN", 5))
  2455. d1973 4
  2456. a1976 7
  2457.         ParseInfoLine(thisDecode, copy, FALSE);
  2458.         return (TRUE);
  2459.     }
  2460.     if (strstr(orig, "Wincode"))
  2461.     {
  2462.         if (sscanf (copy, "section %d/%d   file %s", &seq, &num, name) == 3)
  2463.         {
  2464. d1978 3
  2465. a1980 2
  2466.             thisNumBlocks = num;
  2467.             thisDecode->seqConfidence = HIGH; 
  2468. d1982 1
  2469. d1985 2
  2470. a1986 4
  2471.     }
  2472.      if (strstr(orig, "EnUU"))
  2473.     {
  2474.         if (sscanf (copy, "section %d/%d %s", &seq, &num, name) == 3)
  2475. d1995 2
  2476. a1996 4
  2477.     }
  2478.     if (!strncmp(orig, "POST", 4))
  2479.     {
  2480.         if (sscanf (copy, "POST V%*s %s (Part %d/%d)", name, &seq, &num) == 3)
  2481. d2000 1
  2482. a2000 1
  2483.             thisDecode->seqConfidence = HIGH;
  2484. d2004 30
  2485. @
  2486.  
  2487.  
  2488. 1.9
  2489. log
  2490. @FindExecutable fix for NT
  2491. @
  2492. text
  2493. @d37 1
  2494. a37 1
  2495.  * $Id: wvcoding.c 1.8 1994/08/11 20:16:25 rushing Exp $
  2496. d39 3
  2497. d116 1
  2498. a116 1
  2499. void    DestroyCodedBlock (TypCoded *thisCoded);
  2500. d220 1
  2501. a220 1
  2502.                 return;
  2503. d351 1
  2504. a351 1
  2505.     DestroyCodedBlock (currentCoded);
  2506. d625 1
  2507. a625 1
  2508.     TypCoded *thisCoded;
  2509. d691 1
  2510. a691 1
  2511.         DestroyCodedBlock (threadList[num]->codedBlockList[i]);
  2512. d704 1
  2513. a704 1
  2514.  *    Free the huge data
  2515. d707 1
  2516. a707 1
  2517. DestroyCodedBlock (TypCoded *thisCoded)
  2518. a708 1
  2519.     
  2520. d710 1
  2521. a710 1
  2522.     sprintf(debug, "\nDestroying block sequence %d", thisCoded->sequence);
  2523. d713 3
  2524. a715 2
  2525.     GlobalFreePtr (thisCoded->data);
  2526.     GlobalFreePtr (thisCoded);
  2527. d844 3
  2528. a846 3
  2529.     if (threadList[num]->contentType[0] == '\0')
  2530.         strcpy (threadList[num]->contentType, thisContentType);
  2531.     if (threadList[num]->expectedNumBlocks == 0)
  2532. d988 1
  2533. a988 1
  2534.         DestroyCodedBlock (currentCoded);
  2535. d1053 1
  2536. a1053 1
  2537.                 DestroyCodedBlock (threadList[num]->codedBlockList[0]);
  2538. d1113 1
  2539. a1113 1
  2540.     DestroyCodedBlock (threadList[num]->codedBlockList[0]);
  2541. d1382 2
  2542. d1604 1
  2543. a1604 1
  2544.     for (i = 0; i < dataLen; i++)
  2545. d1869 1
  2546. d1873 2
  2547. a1874 1
  2548.  *    pfile=xyz.abc
  2549. d1879 1
  2550. a1879 1
  2551.     char *orig, *ptr;
  2552. a1901 3
  2553.         if ((ptr = strpbrk(name, " \n\t\r\f")))    
  2554.             *ptr = '\0';
  2555.  
  2556. d1907 5
  2557. a1911 3
  2558.         if ((ptr = strpbrk(name, " \n\t\r\f")))    
  2559.             *ptr = '\0';
  2560.  
  2561. d1913 3
  2562. d1932 13
  2563. d1972 1
  2564. d1998 2
  2565. a1999 1
  2566.     int len, err;
  2567. d2038 1
  2568. a2038 1
  2569.         sprintf(mybuf, "Error executing %s, error %d", execute, err);
  2570. @
  2571.  
  2572.  
  2573. 1.8
  2574. log
  2575. @bug fix
  2576. @
  2577. text
  2578. @d37 1
  2579. a37 1
  2580.  * $Id: wvcoding.c 1.6 1994/07/25 20:05:13 jcooper Exp $
  2581. d39 3
  2582. d1977 1
  2583. a1977 1
  2584.     char mybuf[MAXINTERNALLINE];    
  2585. d1979 1
  2586. d1986 1
  2587. a1986 1
  2588.         
  2589. d2001 1
  2590. a2001 1
  2591.         else 
  2592. d2004 1
  2593. a2004 1
  2594.         UpdateThreadStatus (num, mybuf);            
  2595. d2008 4
  2596. d2015 1
  2597. a2015 1
  2598.         UpdateThreadStatus (num, mybuf);            
  2599. d2020 2
  2600. a2021 2
  2601.         UpdateThreadStatus (num, mybuf);            
  2602.     }    
  2603. @
  2604.  
  2605.  
  2606. 1.7
  2607. log
  2608. @Enhancements to Mime and article encoding/encoding
  2609. @
  2610. text
  2611. @a1814 1
  2612.     
  2613. a1853 1
  2614.  
  2615. d1874 5
  2616. a1878 2
  2617.        for (orig = line; *orig && isspace(*orig); *orig++);    // skip leading spaces
  2618.  
  2619. @
  2620.  
  2621.  
  2622. 1.6
  2623. log
  2624. @execution of decoded files
  2625. @
  2626. text
  2627. @d30 1
  2628. a30 1
  2629.  * Author: John S. Cooper (jcoop@@apl.com)                           *
  2630. a34 1
  2631.  * Please do not use this code for profit or damage                 *
  2632. d37 1
  2633. a37 1
  2634.  * $Id: wvcoding.c 1.5 1994/05/23 18:36:00 jcooper Exp $
  2635. d39 3
  2636. d101 1
  2637. a101 1
  2638. char     thisBlockIdent[MAXFILENAME], prevBlockIdent[MAXFILENAME];
  2639. d117 2
  2640. a118 2
  2641. void    ParseSubjectLine (TypCoded *thisDecode, char *line);
  2642. void    ParseREMLine (TypCoded *thisDecode, char *line);
  2643. d139 1
  2644. a139 1
  2645. char     debug[255];
  2646. d294 1
  2647. a294 1
  2648.     if (AskForNewFileName (hParentWnd, fileName, ""))
  2649. a529 1
  2650.     thisBlockIdent[0] = '\0';
  2651. d599 1
  2652. a599 1
  2653.             sprintf (mybuf, "%sCompleteness confidence is pretty mediocre, written total size %ld", name, threadList[0]->totalBytes);
  2654. d607 1
  2655. d816 1
  2656. a816 1
  2657.       
  2658. d907 1
  2659. d1042 1
  2660. a1042 1
  2661.           currentCoded->seqConfidence == HIGH)
  2662. a1082 3
  2663.         if (ExecuteDecodedFiles)
  2664.             ExecuteDecodedFile(num, threadList[num]->dosFileName);
  2665.  
  2666. d1135 3
  2667. d1245 1
  2668. a1245 1
  2669.     if (strlen(line) < 3)    /* skip over short/blank lines */
  2670. d1280 5
  2671. a1284 3
  2672.              ParseSubjectLine (thisDecode, &line[8]);
  2673.          else if (!DumbDecode && strstr(line, "R.E.M."))
  2674.              ParseREMLine (thisDecode, line);
  2675. a1371 1
  2676.             thisBlockIdent[0] = '\0';            
  2677. d1683 3
  2678. a1685 2
  2679.  *    Search through a subject line (the Subject: part has already been 
  2680.  *    removed).
  2681. d1687 5
  2682. a1691 2
  2683.  *    Generate an identifier based on the subejct, preferably based on the
  2684.  *    actual file name
  2685. d1695 1
  2686. a1695 1
  2687.  *    Common styles which this function deals with:
  2688. d1705 7
  2689. d1729 1
  2690. a1729 1
  2691. ParseSubjectLine (TypCoded *thisDecode, char *line)
  2692. a1738 2
  2693.     thisNumBlocks = -1;
  2694.     thisBlockIdent[0] = '\0';
  2695. d1782 2
  2696. a1783 1
  2697.             else
  2698. d1796 1
  2699. d1798 1
  2700. a1798 2
  2701.  
  2702.     if (thisDecode->ident[0] == '\0')
  2703. d1823 1
  2704. a1823 1
  2705.  */
  2706. d1856 14
  2707. a1869 3
  2708. // example: "section N of uuencode 5.10 of file abcd.gef   by R.E.M."
  2709. void
  2710. ParseREMLine (TypCoded *thisDecode, char *line)
  2711. d1871 2
  2712. a1872 2
  2713.     char *ptr;
  2714.     int seq;
  2715. d1874 1
  2716. d1876 84
  2717. a1959 5
  2718.     AnsiLowerBuff ((LPSTR)line, (UINT)strlen(line));
  2719.        ptr = line;
  2720.        while (*ptr && isspace(*ptr)) *ptr++;
  2721.     if (sscanf (ptr, "section %d of uuencode %*f of file %s", &seq, name) != 2)
  2722.         return;
  2723. d1961 1
  2724. a1961 5
  2725.     thisDecode->sequence = seq;
  2726.     if (!thisDecode->seqConfidence)
  2727.         thisDecode->seqConfidence = LOW; // still don't have number of parts
  2728.         
  2729.     strcpy (thisDecode->ident, name);
  2730. d1998 1
  2731. a1998 1
  2732.         sprintf(mybuf, "No association for file type %s", ext);
  2733. d2005 1
  2734. a2005 1
  2735.         sprintf(mybuf, "Error running %s, error %d", execute, err);
  2736. d2010 1
  2737. a2010 1
  2738.         sprintf(mybuf, "Sucessfully executed %s", execute);
  2739. @
  2740.  
  2741.  
  2742. 1.5
  2743. log
  2744. @new attach code, session [dis]connect
  2745. @
  2746. text
  2747. @d38 1
  2748. a38 1
  2749.  * $Id: wvcoding.c 1.4 1994/03/01 19:14:22 rushing Exp $
  2750. d40 3
  2751. d116 1
  2752. d131 2
  2753. d278 10
  2754. a287 8
  2755.     register unsigned long i;
  2756.     char fileName[MAXFILENAME];
  2757.         OFSTRUCT outFileStruct;
  2758.         HFILE hAttachFile;
  2759.         TypTextBlock *encodeData;
  2760.  
  2761.     if ((encodeData = InitTextBlock (hParentWnd)) == NULL)
  2762.         return;
  2763. d289 2
  2764. a290 6
  2765.     CreateStatusArea(hParentWnd);
  2766.         strcpy (currentCoded->ident, inFile);    // status window info
  2767.  
  2768.     if (Encode (encodeData, inFile, ADD_TO_FILE) == FAIL)
  2769.         return;
  2770.  
  2771. d292 1
  2772. a292 4
  2773.     if (AskForNewFileName (hParentWnd, fileName, "") == FAIL)
  2774.         return;
  2775.         
  2776.     if ((hAttachFile = OpenFile ((char far *) fileName, &outFileStruct, OF_CREATE)) < 0)
  2777. d294 1
  2778. d296 11
  2779. a306 9
  2780.         return;
  2781.            }
  2782.     for (i = 0; i < encodeData->numLines; i++)
  2783.         _lwrite (hAttachFile, TextBlockLine (encodeData, i), lstrlen(TextBlockLine (encodeData, i)));
  2784.     
  2785.     _lclose (hAttachFile);
  2786.     FreeTextBlock (encodeData);
  2787.     DestroyCodedBlock (currentCoded);    // free status blk (created in Encode)
  2788.     DestroyWindow (hCodedBlockWnd);        // close status window
  2789. d321 2
  2790. a322 1
  2791.  
  2792. d1080 3
  2793. d1159 6
  2794. a1164 1
  2795.            sprintf (actualFileName, "%s\\%s", DecodePathName, threadList[num]->dosFileName);
  2796. d1180 6
  2797. a1185 1
  2798.             sprintf (actualFileName, "%s\\%s", DecodePathName, threadList[num]->dosFileName);
  2799. d1188 1
  2800. a1188 1
  2801.             return (FAIL);
  2802. d1278 2
  2803. d1841 21
  2804. a1862 1
  2805. #ifdef OLD
  2806. d1864 1
  2807. a1864 1
  2808. OldParseSubjectLine (TypCoded *thisDecode, char *line)
  2809. d1866 23
  2810. a1888 50
  2811.     char *beg, *end;
  2812.     char temp[30];
  2813.     int len, thisBlockPart;
  2814.     
  2815.     beg = line;
  2816.     /* skip to beginning of filename */
  2817.     while (!isalnum(*beg)) beg++;    
  2818.     
  2819.     if ((end = strpbrk (beg, " ([:"))) == NULL)
  2820.     {
  2821.         thisBlockPart = -1;
  2822.         len = min (strlen (beg), MAXFILENAME-1);
  2823.         strncpy (thisBlockName, beg, len);
  2824.         thisBlockName[len] = '\0';
  2825.     }        
  2826.     else 
  2827.     { 
  2828.         len = min (end-beg, MAXFILENAME-1);
  2829.         strncpy (thisBlockName, beg,len);
  2830.         thisBlockName[len] = '\0';
  2831.         RemoveTrailingWhiteSpace(thisBlockName);
  2832.  
  2833.         /* skip delimiter, then skip to part number */
  2834.         for (beg = end + 1; *beg != '\0' && !isdigit(*beg); beg++);
  2835.         if (*beg == '\0')
  2836.             thisBlockPart = -1;
  2837.                 else {
  2838.                     /* find end of number, then put number in temp */
  2839.             for (end = beg + 1;  *end != '\0' && isdigit(*end); end++);
  2840.             strncpy (temp, beg, end-beg);
  2841.             temp[end-beg] = '\0';
  2842.             
  2843.             if ((thisBlockPart = atoi (temp)) == 0)
  2844.                 thisBlockPart = -1;
  2845.             
  2846.             /* skip to next number (num parts) */
  2847.             for (beg = end + 1; *beg != '\0' && !isdigit(*beg); beg++);
  2848.             if (*beg == '\0')
  2849.                 thisNumBlocks = -1;
  2850.             else {
  2851.                         /* find end of number, then put number in temp */
  2852.                 for (end = beg + 1;  *end != '\0' && isdigit(*end); end++);
  2853.                 strncpy (temp, beg, end-beg);
  2854.                 temp[end-beg] = '\0';
  2855.  
  2856.                 if ((thisNumBlocks = atoi (temp)) == 0)
  2857.                     thisNumBlocks = -1;
  2858.                 else if (thisBlockPart > thisNumBlocks)
  2859.                     thisBlockPart = -1;
  2860.             }
  2861. d1890 10
  2862. a1900 1
  2863.     strcpy (thisDecode->name, thisBlockName);
  2864. d1902 10
  2865. a1911 3
  2866.     thisDecode->sequence = thisBlockPart;
  2867.     SendMessage (hCodedBlockWnd, WM_PAINT, STATUS_NAME|STATUS_SEQUENCE, (LPARAM)NULL);
  2868.     InvalidateRect (hCodedBlockWnd, NULL, FALSE);
  2869. a1912 2
  2870.  
  2871. #endif
  2872. @
  2873.  
  2874.  
  2875. 1.4
  2876. log
  2877. @ifdef'd the DEBUG info
  2878. @
  2879. text
  2880. @d38 1
  2881. a38 1
  2882.  * $Id: wvcoding.c 1.3 1994/02/24 21:28:04 jcoop Exp $
  2883. d40 3
  2884. d284 2
  2885. a285 1
  2886.     Encode (encodeData, inFile, ADD_TO_FILE);
  2887. d349 1
  2888. a349 1
  2889. void
  2890. d362 1
  2891. a362 1
  2892.     switch (EncodingType)
  2893. d377 2
  2894. a378 1
  2895.         AddEndedLineToTextBlock (textBlock, "table", mode);
  2896. d381 2
  2897. a382 1
  2898.         AddEndedLineToTextBlock (textBlock, str, mode);
  2899. d384 2
  2900. a385 1
  2901.         AddEndedLineToTextBlock (textBlock, str, mode);
  2902. d390 1
  2903. a390 1
  2904.     switch (EncodingType)
  2905. d400 2
  2906. a401 1
  2907.         AddEndedLineToTextBlock (textBlock, outLine, mode);
  2908. d422 1
  2909. a422 1
  2910.             if (EncodingType != CODE_BASE64)
  2911. d429 2
  2912. a430 1
  2913.         AddEndedLineToTextBlock (textBlock, outLine, mode);
  2914. d437 1
  2915. a437 1
  2916.     switch (EncodingType)
  2917. d445 2
  2918. a446 1
  2919.         AddEndedLineToTextBlock (textBlock, outLine, mode);
  2920. d449 2
  2921. a450 1
  2922.         AddEndedLineToTextBlock (textBlock, outLine, mode);
  2923. d456 1
  2924. d482 1
  2925. a482 1
  2926.         if (EncodingType == CODE_BASE64)
  2927. d490 1
  2928. a490 1
  2929.         if (EncodingType == CODE_BASE64)
  2930. @
  2931.  
  2932.  
  2933. 1.3
  2934. log
  2935. @jcoop changes.
  2936. @
  2937. text
  2938. @d38 1
  2939. a38 1
  2940.  * $Id: wvcoding.c 1.2 1994/02/09 18:01:08 cnolan Exp $
  2941. d40 3
  2942. d58 2
  2943. d63 1
  2944. @
  2945.  
  2946.  
  2947. 1.2
  2948. log
  2949. @cnolan 90.2 changes
  2950. @
  2951. text
  2952. @d38 1
  2953. a38 1
  2954.  * $Id: wvcoding.c 1.1 1994/01/18 09:54:20 jcoop Exp $
  2955. d40 3
  2956. d55 3
  2957. a57 3
  2958. //#define DEBUG_MAP
  2959. //#define DEBUG_MEM
  2960. //#define DEBUG_DECODE
  2961. d64 1
  2962. a64 1
  2963. #define ENCODE_LINE_LEN    45    
  2964. d68 1
  2965. a68 1
  2966. static char
  2967. d70 1
  2968. a70 1
  2969. static char
  2970. d72 1
  2971. a72 1
  2972. static char
  2973. d74 2
  2974. a75 3
  2975. char    xxMap[128], uuMap[128], thisMap[128];
  2976. char    *codingMap, *codingTable;
  2977. char    thisTable[CODINGTABLESIZE], prevTable[CODINGTABLESIZE];
  2978. a81 1
  2979. BOOL    customTable;            // = TRUE if found custom table
  2980. a83 1
  2981. int    thisContentEncoding;
  2982. d85 2
  2983. d92 1
  2984. a92 1
  2985. void    EncodeUnit (unsigned char *out, unsigned char *in);
  2986. d115 1
  2987. a115 1
  2988. BOOL    ThreadTable (char *dest, char *name);
  2989. d166 1
  2990. a166 1
  2991.         char mybuf[MAXINTERNALLINE], fileName[MAXFILENAME];
  2992. d183 1
  2993. a183 1
  2994.            while (fgets(mybuf, MAXINTERNALLINE, DecodeFile) != NULL)
  2995. d185 3
  2996. d200 2
  2997. d313 2
  2998. a314 2
  2999.     width = 75 * StatusCharWidth;
  3000.     height = 10 * StatusLineHeight;
  3001. d344 2
  3002. a345 1
  3003.     unsigned char inBuf[ENCODE_LINE_LEN];
  3004. d354 1
  3005. a354 1
  3006.     case ENCODE_BASE64:    
  3007. d357 2
  3008. a358 2
  3009.     case ENCODE_UU:
  3010.         codingTable = uuTable;;
  3011. d360 1
  3012. a360 1
  3013.     case ENCODE_XX:
  3014. d362 1
  3015. a362 1
  3016.         codingTable = xxTable;;
  3017. d364 1
  3018. a364 1
  3019.     case ENCODE_CUSTOM:
  3020. d379 5
  3021. a383 3
  3022.     case ENCODE_UU:
  3023.     case ENCODE_XX:
  3024.     case ENCODE_CUSTOM:
  3025. d390 1
  3026. a390 1
  3027.             outLine[0] = codingTable[ENCODE_LINE_LEN];
  3028. d393 3
  3029. a395 1
  3030.     case ENCODE_BASE64:
  3031. d398 1
  3032. a398 1
  3033.     lineLen = ENCODE_LINE_LEN;
  3034. d407 7
  3035. a413 2
  3036.             outLine[0] = codingTable[numRead];
  3037.  
  3038. d424 3
  3039. a426 3
  3040.     case ENCODE_UU:
  3041.     case ENCODE_XX:
  3042.     case ENCODE_CUSTOM:
  3043. d451 1
  3044. a451 1
  3045.         EncodeUnit (&outLine[j], &line[i]);
  3046. d458 1
  3047. a458 1
  3048. EncodeUnit (unsigned char *out, unsigned char *in)
  3049. d462 7
  3050. d470 7
  3051. a494 3
  3052. //    Note, XX table is hard coded in declarations for simplicity
  3053.     CreateCodingMap(uuMap, uuTable);
  3054.     CreateCodingMap(xxMap, xxTable);
  3055. d507 3
  3056. a509 2
  3057.     thisTable[0] = '\0';
  3058.     prevTable[0] = '\0';
  3059. d516 2
  3060. a517 2
  3061.     width = 75 * StatusCharWidth;
  3062.     height = 10 * StatusLineHeight;
  3063. d561 2
  3064. a562 1
  3065.         else if (!threadList[0]->codedBlockList[threadList[0]->numBlocks-1]->endFlag)
  3066. a616 1
  3067. //    thisCoded->altName[0] = '\0';
  3068. a618 1
  3069.         customTable = FALSE;
  3070. d757 3
  3071. a759 1
  3072.         strncpy (threadList[num]->codingTable, thisTable, CODINGTABLESIZE);
  3073. d989 2
  3074. a990 5
  3075. /* Save this coding table, and blank out the current table
  3076.  * This will cause the next block to start decoding w/ a clean slate
  3077.  */
  3078.     strncpy (prevTable, thisTable, CODINGTABLESIZE);
  3079.     thisTable[0] = '\0';
  3080. d1142 2
  3081. a1143 1
  3082.  
  3083. d1146 1
  3084. a1146 1
  3085.         else
  3086. d1148 2
  3087. a1149 1
  3088.         sprintf (actualFileName, "%s\\%s", DecodePathName, threadList[num]->dosFileName);
  3089. d1216 2
  3090. a1217 1
  3091. /* encoded data always starts with line like 'begin <mode> <file-name>' */
  3092. d1237 2
  3093. a1238 2
  3094. /* Check for keywords in the non-data lines which may aid in describing the line length,
  3095.  * the destination file for this data, the sequence, etc
  3096. d1273 1
  3097. a1273 1
  3098.         memmove ((thisTable + table_count * 32), line, 32);
  3099. d1278 1
  3100. a1278 1
  3101.             strncpy (str, thisTable, 64);
  3102. d1284 1
  3103. a1284 1
  3104.             if (i = CreateCodingMap (thisMap, thisTable) != -1)
  3105. d1290 1
  3106. a1290 2
  3107.             codingMap = thisMap;
  3108.             customTable = TRUE;
  3109. d1301 2
  3110. a1302 1
  3111.         if (!_strnicmp (line, "end", 3) || !IsDataLine(line))
  3112. d1311 1
  3113. a1311 1
  3114.  * data yet (< about a line's worth), then the line which gave us the table
  3115. d1315 1
  3116. a1315 1
  3117.  * this line.  Note if we have a customTable, then we trust it.
  3118. d1317 1
  3119. a1317 1
  3120.             if (!customTable && thisDecode->numBytes < 80)
  3121. d1320 1
  3122. a1320 1
  3123.                 thisTable[0] = '\0';
  3124. d1346 1
  3125. a1346 1
  3126.  * Decode a data line
  3127. d1350 48
  3128. a1397 14
  3129.     register unsigned int i, j;
  3130.     unsigned int charCount, numDecoded, checkSum;
  3131.     unsigned char buf[4], outLine[120];
  3132.     
  3133.     checkSum = charCount = codingMap[line[0]];    // count is # of chars after decoding
  3134.     for (i = 1, numDecoded=0; numDecoded < charCount;)
  3135.     {
  3136. /* Get the next group of four characters */
  3137.         for (j = 0; j < 4; j++, i++)
  3138.             checkSum += (buf[j] = codingMap[line[i]]); 
  3139.         
  3140.             outLine[numDecoded++] = buf[0]<<2|buf[1]>>4;
  3141.         outLine[numDecoded++] = buf[1]<<4|buf[2]>>2;
  3142.         outLine[numDecoded++] = buf[2]<<6|buf[3];
  3143. d1399 8
  3144. a1406 2
  3145.     if (AddDataToBlock (currentCoded, outLine, numDecoded) == FAIL)
  3146.         return (FAIL);
  3147. d1415 1
  3148. a1415 1
  3149.     return (SUCCESS);
  3150. a1428 1
  3151. //            thisDecode->maxBytes *= 2L;    // must always be a power of 2 
  3152. a1443 2
  3153.  *    If this is a new block (thisTable is empty), auto-determine what
  3154.  *    encoding scheme is used
  3155. d1448 1
  3156. a1448 1
  3157.     if (thisTable[0] == '\0')
  3158. d1450 4
  3159. a1453 3
  3160. /* If this block has same ident as prev, use same decode table
  3161.  * If diff name, use table stored in thread w/ same name, or if none 
  3162.  * try to auto-detect
  3163. d1458 1
  3164. a1458 3
  3165.             strncpy (thisTable, prevTable, CODINGTABLESIZE);
  3166.             CreateCodingMap (thisMap, thisTable);
  3167.             codingMap = thisMap;
  3168. d1465 1
  3169. a1465 1
  3170.             if (ThreadTable (thisTable, currentCoded->ident) == SUCCESS)
  3171. d1467 2
  3172. a1468 2
  3173.                 CreateCodingMap (thisMap, thisTable);
  3174.                 codingMap = thisMap;
  3175. d1476 1
  3176. a1476 1
  3177.                 codingMap = uuMap;
  3178. a1482 1
  3179.                     strncpy (thisTable, uuTable, CODINGTABLESIZE);
  3180. d1485 1
  3181. a1485 1
  3182.                 codingMap = xxMap;
  3183. a1491 1
  3184.                     strncpy (thisTable, xxTable, CODINGTABLESIZE);
  3185. d1494 10
  3186. d1513 11
  3187. a1523 2
  3188.     unsigned int expectedLineLen, dataLen, lineLen;
  3189.     register unsigned int i;
  3190. d1525 2
  3191. a1526 2
  3192.  * The first char of a good data line is the encoded character count for the 
  3193.  * line.  
  3194. d1530 3
  3195. a1532 2
  3196.  * The count INCLUDES the first count char
  3197.  * If the line length is actually 1 + count, then we have a checksum
  3198. d1534 1
  3199. a1534 1
  3200.     expectedLineLen = 4 * ((codingMap[line[0]] + 2) / 3);
  3201. d1536 1
  3202. a1536 1
  3203.     if ((lineLen = strlen(line)) < expectedLineLen)
  3204. d1542 1
  3205. a1542 1
  3206.  * Don't remove all trailing white space!
  3207. d1544 3
  3208. a1546 3
  3209.      for (dataLen = lineLen - 1; 
  3210.           strchr(" \t\n\r",line[dataLen]) && dataLen > 0 && dataLen != expectedLineLen; 
  3211.           dataLen--);
  3212. d1552 1
  3213. d1555 1
  3214. a1555 1
  3215.         if (codingMap[line[i]] == UNUSED)
  3216. d1558 17
  3217. a1579 11
  3218. void
  3219. CreateUUTable()
  3220. {
  3221.     register unsigned int i;
  3222.  
  3223.     for (i=0; i < CODINGTABLESIZE; i++)
  3224.         uuTable[i] = i + 32;
  3225.     
  3226.     uuTable[0] = 96;        /* set space to map to back-quote */    
  3227. }
  3228.  
  3229. a1596 2
  3230.     map[' ']=0;                // decode space to 0
  3231.  
  3232. d1608 1
  3233. a1608 1
  3234. BOOL   
  3235. d1619 1
  3236. a1619 4
  3237.     {
  3238.         dest[0]='\0';
  3239.         return (FAIL);
  3240.     }
  3241. d1622 3
  3242. a1624 2
  3243.         strncpy (dest, threadList[num]->codingTable, CODINGTABLESIZE);
  3244.         return (SUCCESS);
  3245. d1627 13
  3246. a1802 90
  3247. /* ------------------------------------------------------------------------
  3248.  * Check a line to see if it's MIME.  If so, do something intelligent with
  3249.  * it. Note, any MIME header MUST start with 'MIME-version'
  3250.  */
  3251. int
  3252. ParseMimeHeaderLine (TypCoded *thisDecode, char *line)
  3253. {
  3254.         char *ptr;
  3255.  
  3256.     // gotta start with MIME-version, or it ain't MIME
  3257.     if (!bossanovaMIME)            
  3258.         if (!_strnicmp (line, "mime-version", 12))
  3259.         {
  3260.             bossanovaMIME = TRUE;        // hooray
  3261.             return (SUCCESS);
  3262.         }
  3263.         else
  3264.             return (FAIL);
  3265.         
  3266.     if (ParseMimeContentType (thisDecode, line) == SUCCESS)
  3267.         return (SUCCESS);
  3268.         
  3269.     if (!_strnicmp (line, "content-transfer-encoding:", 26))
  3270.     {
  3271.         for (ptr = &line[26]; *ptr && isspace(*ptr); ptr++);
  3272.             if (!_strnicmp (ptr, "x-uue", 5))
  3273.                 thisContentEncoding = ENCODE_UU;
  3274.             else if (!_strnicmp (ptr, "x-xxe", 5))
  3275.                 thisContentEncoding = ENCODE_XX;
  3276.             else if (!_strnicmp (ptr, "base64", 6))
  3277.                 thisContentEncoding = ENCODE_BASE64;
  3278.             else if (!_strnicmp (ptr, "quoted-printable",16))
  3279.                 thisContentEncoding = ENCODE_QP;
  3280.             else
  3281.                 thisContentEncoding = ENCODE_UNKNOWN;
  3282.         return (SUCCESS);
  3283.     }
  3284.     if (!_strnicmp (line, "content-description:", 20))
  3285.     {
  3286.         strcpy (thisContentDesc, &line[20]);
  3287.         return (SUCCESS);
  3288.     }
  3289.     if (!_strnicmp (line, "content-length", 14))
  3290.         return (SUCCESS);
  3291.  
  3292.    return (FAIL);
  3293. }
  3294.  
  3295. int
  3296. ParseMimeContentType (TypCoded *thisDecode, char *line)
  3297. {
  3298.     static int mimeContentLevel = 0;
  3299.     BOOL recurse = FALSE;
  3300.     char *ptr;
  3301.     
  3302.     if (mimeContentLevel == 0)
  3303.         if (!_strnicmp (line, "content-type:", 13))
  3304.         {
  3305.             ptr = strchr (&line[13], ';');    // check for parameters
  3306.             if (*ptr != '\0')
  3307.             {
  3308.                 *ptr = '\0';            // replace ; with \0
  3309.                 if (*(ptr+1) != '\0')
  3310.                     recurse = TRUE;
  3311.             }
  3312.             strcpy (thisContentType, &line[13]);
  3313.             mimeContentLevel++;
  3314.             if (recurse)        // parse same-line parameters
  3315.                 ParseMimeContentType (thisDecode, ptr);
  3316.                 
  3317.             return (SUCCESS);
  3318.         } else
  3319.             return (FAIL);
  3320.     
  3321.     if (!_strnicmp (line, "id=", 3))
  3322.     {
  3323.         ptr = strchr (&line[3], ';');    // check for parameters
  3324.         if (*ptr != '\0')
  3325.         {
  3326.             *ptr = '\0';            // replace ; with \0
  3327.             if (*(ptr+1) != '\0')
  3328.                 recurse = TRUE;
  3329.         }
  3330.         strcpy (thisDecode->ident, &line[3]);
  3331.         if (recurse)        // parse same-line parameters
  3332.             ParseMimeContentType (thisDecode, ptr);
  3333.         return (SUCCESS);
  3334.     }
  3335.     return (FAIL);                
  3336. }
  3337. @
  3338.  
  3339.  
  3340. 1.1
  3341. log
  3342. @Initial revision
  3343. @
  3344. text
  3345. @d38 5
  3346. a42 2
  3347.  * $Id:  $
  3348.  * $Log:  $
  3349. d315 1
  3350. a315 1
  3351.     SetClassWord (hCodedBlockWnd, GCW_HBRBACKGROUND, hStatusBackgroundBrush);
  3352. d389 1
  3353. a389 1
  3354.         hFile = _lopen (fileName, READ);
  3355. d496 1
  3356. a496 1
  3357.     SetClassWord (hCodedBlockWnd, GCW_HBRBACKGROUND, hStatusBackgroundBrush);
  3358. d768 2
  3359. a769 2
  3360.            SetClassWord (threadList[num]->statusText->hTextWnd,
  3361.                  GCW_HBRBACKGROUND, hStatusBackgroundBrush);
  3362. @
  3363.